private IRawFileSystem GetSystem(string path)
{
IRawFileSystem system;
var driveLetter = path[0];
if (!char.IsLetter(driveLetter))
{
throw new ArgumentException($"Path '{path}' did not have a drive letter!");
}
if (systems.TryGetValue(driveLetter, out system))
{
return(system);
}
try
{
var disk = new RawDisk(driveLetter);
var rawDiskStream = disk.CreateDiskStream();
system = new NtfsFileSystem(rawDiskStream);
systems.Add(driveLetter, system);
}
catch (Exception)
{
Console.WriteLine("Failed to create a filesystem for drive '{0}'", driveLetter);
throw;
}
return(system);
}
public NtfsFileStream(NtfsFileSystem fileSystem, DirectoryEntry entry, AttributeType attrType, string attrName, FileAccess access)
{
_entry = entry;
_file = fileSystem.GetFile(entry.Reference);
_baseStream = _file.OpenStream(attrType, attrName, access);
}
public void ShortNames()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
// Check we can find a short name in the same directory
using (Stream s = ntfs.OpenFile("ALongFileName.txt", FileMode.CreateNew)) {}
ntfs.SetShortName("ALongFileName.txt", "ALONG~01.TXT");
Assert.Equal("ALONG~01.TXT", ntfs.GetShortName("ALongFileName.txt"));
Assert.True(ntfs.FileExists("ALONG~01.TXT"));
// Check path handling
ntfs.CreateDirectory("DIR");
using (Stream s = ntfs.OpenFile(@"DIR\ALongFileName2.txt", FileMode.CreateNew)) { }
ntfs.SetShortName(@"DIR\ALongFileName2.txt", "ALONG~02.TXT");
Assert.Equal("ALONG~02.TXT", ntfs.GetShortName(@"DIR\ALongFileName2.txt"));
Assert.True(ntfs.FileExists(@"DIR\ALONG~02.TXT"));
// Check we can open a file by the short name
using (Stream s = ntfs.OpenFile("ALONG~01.TXT", FileMode.Open)) { }
// Delete the long name, and make sure the file is gone
ntfs.DeleteFile("ALONG~01.TXT");
Assert.False(ntfs.FileExists("ALONG~01.TXT"));
// Delete the short name, and make sure the file is gone
ntfs.DeleteFile(@"DIR\ALONG~02.TXT");
Assert.False(ntfs.FileExists(@"DIR\ALongFileName2.txt"));
}
/// <summary>
/// This method creates a .vhd hard drive formatted in NTFS.
/// </summary>
/// <param name="diskSize">The size of the disk in bytes.</param>
/// <param name="location">Defines the physical location and file name. .vhd extension required.</param>
/// <param name="label">The label to be given to the disk.</param>
/// <param name="dynamic">Determines whether or not the disk will be of fixed size or dynamic size.</param>
/// <returns>A bool determining if the method succeeded.</returns>
public bool CreateNtfsDrive(long diskSize, string location, string label, bool dynamic)
{
try
{
using (Stream vhdStream = File.Create(@location))
{
Disk disk = null;
if (dynamic)
{
disk = Disk.InitializeDynamic(vhdStream, Ownership.None, diskSize);
}
else
{
disk = Disk.InitializeFixed(vhdStream, Ownership.None, diskSize);
}
BiosPartitionTable.Initialize(disk, WellKnownPartitionType.WindowsNtfs);
NtfsFileSystem.Format(new VolumeManager(disk).GetLogicalVolumes()[0], label);
return(true);
}
}
catch (IOException e)
{
Console.WriteLine(e.StackTrace);
return(false);
}
}
public static DiscFileSystem FormatStream(string fileSystemName, Stream stream, long size, string label)
{
switch (fileSystemName)
{
case "NTFS":
{
var geometry = FindBasicGeometry(stream, size);
Logger.Info("Formatting stream as NTFS");
return(NtfsFileSystem.Format(stream, label, geometry, 0, geometry.TotalSectorsLong));
}
case "FAT":
{
var geometry = FindBasicGeometry(stream, size);
Logger.Info("Formatting stream as FAT");
#pragma warning disable CS0618 // Typ oder Element ist veraltet
return(FatFileSystem.FormatPartition(stream, label, geometry, 0, geometry.TotalSectors, 0));
#pragma warning restore CS0618 // Typ oder Element ist veraltet
}
default:
{
Logger.Error("Requested file system is not supported (Requested {0}, supported: NTFS, FAT)",
fileSystemName);
Environment.Exit(1);
break;
}
}
return(null);
}
public void GetFileLength()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
ntfs.OpenFile(@"AFILE.TXT", FileMode.Create).Dispose();
Assert.Equal(0, ntfs.GetFileLength("AFILE.TXT"));
using (var stream = ntfs.OpenFile(@"AFILE.TXT", FileMode.Open))
{
stream.Write(new byte[14325], 0, 14325);
}
Assert.Equal(14325, ntfs.GetFileLength("AFILE.TXT"));
using (var attrStream = ntfs.OpenFile(@"AFILE.TXT:altstream", FileMode.Create))
{
attrStream.Write(new byte[122], 0, 122);
}
Assert.Equal(122, ntfs.GetFileLength("AFILE.TXT:altstream"));
// Test NTFS options for hardlink behaviour
ntfs.CreateDirectory("Dir");
ntfs.CreateHardLink("AFILE.TXT", @"Dir\OtherLink.txt");
using (var stream = ntfs.OpenFile("AFILE.TXT", FileMode.Open, FileAccess.ReadWrite))
{
stream.SetLength(50);
}
Assert.Equal(50, ntfs.GetFileLength("AFILE.TXT"));
Assert.Equal(14325, ntfs.GetFileLength(@"Dir\OtherLink.txt"));
ntfs.NtfsOptions.FileLengthFromDirectoryEntries = false;
Assert.Equal(50, ntfs.GetFileLength(@"Dir\OtherLink.txt"));
}
void InitializeVhdManually(DiscUtils.Vhd.Disk vhdDisk)
{
BiosPartitionTable.Initialize(vhdDisk, WellKnownPartitionType.WindowsNtfs);
// GuidPartitionTable.Initialize(vhdDisk, WellKnownPartitionType.WindowsNtfs);
var volMgr = new VolumeManager(vhdDisk);
var logicalVolume = volMgr.GetLogicalVolumes()[0];
var label = $"XVDTool conversion";
using (var destNtfs = NtfsFileSystem.Format(logicalVolume, label, new NtfsFormatOptions()))
{
destNtfs.NtfsOptions.ShortNameCreation = ShortFileNameOption.Disabled;
// NOTE: For VHD creation we just assume a single partition
foreach (var file in IterateFilesystem(partitionNumber: 0))
{
var fh = file.OpenRead();
if (!destNtfs.Exists(file.DirectoryName))
{
destNtfs.CreateDirectory(file.DirectoryName);
}
using (Stream dest = destNtfs.OpenFile(file.FullName, FileMode.Create,
FileAccess.ReadWrite))
{
fh.CopyTo(dest);
dest.Flush();
}
fh.Close();
}
}
}
public static DiscFileSystem FormatFileSystemWithTemplate(Stream template, Stream output,
long firstSector, long sectorCount, long availableSpace)
{
if (NtfsFileSystem.Detect(template))
{
var templateFS = new NtfsFileSystem(template);
var newSize = Math.Min(templateFS.Size, availableSpace);
Logger.Verbose("Formatting stream as <NTFS> file system ({0}B, 0x{1}-0x{2})",
newSize, firstSector.ToString("X2"), sectorCount.ToString("X2"));
return(NtfsFileSystem.Format(output, templateFS.VolumeLabel,
Geometry.FromCapacity(newSize), firstSector, sectorCount,
templateFS.ReadBootCode()));
}
/* else if (FatFileSystem.Detect(template))
* {
* var templateFS = new FatFileSystem(template);
* var newSize = Math.Min(templateFS.Size, availableSpace);
*
* Logger.Verbose("Formatting streams as <FAT> ({0}B, 0x{1}-0x{2})",
* newSize, firstSector.ToString("X2"), sectorCount.ToString("X2"));
*
* return FatFileSystem.FormatPartition(output, templateFS.VolumeLabel,
* Geometry.FromCapacity(newSize), (int)firstSector, (int)sectorCount, 13);
* } */
return(null);
}
protected override void ProcessRecord()
{
PSObject volInfoObj = null;
VolumeInfo volInfo = null;
if (InputObject != null)
{
volInfoObj = InputObject;
volInfo = volInfoObj.BaseObject as VolumeInfo;
}
if (volInfo == null && string.IsNullOrEmpty(LiteralPath))
{
WriteError(new ErrorRecord(
new ArgumentException("No volume specified"),
"NoVolumeSpecified",
ErrorCategory.InvalidArgument,
null));
return;
}
if (Filesystem != FileSystemType.Ntfs)
{
WriteError(new ErrorRecord(
new ArgumentException("Unknown filesystem type"),
"BadFilesystem",
ErrorCategory.InvalidArgument,
null));
return;
}
if (volInfo == null)
{
volInfoObj = SessionState.InvokeProvider.Item.Get(LiteralPath)[0];
volInfo = volInfoObj.BaseObject as VolumeInfo;
}
if (volInfo == null)
{
WriteError(new ErrorRecord(
new ArgumentException("Path specified is not a disk volume"),
"BadVolumeSpecified",
ErrorCategory.InvalidArgument,
null));
return;
}
var driveProp = volInfoObj.Properties["PSDrive"];
if (driveProp != null)
{
var drive = driveProp.Value as VirtualDiskPSDriveInfo;
if (drive != null)
{
drive.UncacheFileSystem(volInfo.Identity);
}
}
NtfsFileSystem.Format(volInfo, Label);
}
public void OpenRawStream()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
#pragma warning disable 618
Assert.Null(ntfs.OpenRawStream(@"$Extend\$ObjId", AttributeType.Data, null, FileAccess.Read));
#pragma warning restore 618
}
public static IFileSystem GetFileSystem(char driveLetter, FileAccess fileAccess)
{
var disk = new RawDisk(driveLetter, fileAccess);
var rawDiskStream = disk.CreateDiskStream();
var system = new NtfsFileSystem(rawDiskStream);
return(system);
}
public void Fragmented()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
ntfs.CreateDirectory(@"DIR");
byte[] buffer = new byte[4096];
for (int i = 0; i < 2500; ++i)
{
using (var stream = ntfs.OpenFile(@"DIR\file" + i + ".bin", FileMode.Create, FileAccess.ReadWrite))
{
stream.Write(buffer, 0, buffer.Length);
}
using (var stream = ntfs.OpenFile(@"DIR\" + i + ".bin", FileMode.Create, FileAccess.ReadWrite))
{
stream.Write(buffer, 0, buffer.Length);
}
}
for (int i = 0; i < 2500; ++i)
{
ntfs.DeleteFile(@"DIR\file" + i + ".bin");
}
// Create fragmented file (lots of small writes)
using (var stream = ntfs.OpenFile(@"DIR\fragmented.bin", FileMode.Create, FileAccess.ReadWrite))
{
for (int i = 0; i < 2500; ++i)
{
stream.Write(buffer, 0, buffer.Length);
}
}
// Try a large write
byte[] largeWriteBuffer = new byte[200 * 1024];
for (int i = 0; i < largeWriteBuffer.Length / 4096; ++i)
{
largeWriteBuffer[i * 4096] = (byte)i;
}
using (var stream = ntfs.OpenFile(@"DIR\fragmented.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
stream.Position = stream.Length - largeWriteBuffer.Length;
stream.Write(largeWriteBuffer, 0, largeWriteBuffer.Length);
}
// And a large read
byte[] largeReadBuffer = new byte[largeWriteBuffer.Length];
using (var stream = ntfs.OpenFile(@"DIR\fragmented.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
stream.Position = stream.Length - largeReadBuffer.Length;
stream.Read(largeReadBuffer, 0, largeReadBuffer.Length);
}
Assert.Equal(largeWriteBuffer, largeReadBuffer);
}
public void Sparse()
{
int fileSize = 1 * 1024 * 1024;
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
byte[] data = new byte[fileSize];
for (int i = 0; i < fileSize; i++)
{
data[i] = (byte)i;
}
using (SparseStream s = ntfs.OpenFile("file.bin", FileMode.CreateNew))
{
s.Write(data, 0, fileSize);
ntfs.SetAttributes("file.bin", ntfs.GetAttributes("file.bin") | FileAttributes.SparseFile);
s.Position = 64 * 1024;
s.Clear(128 * 1024);
s.Position = fileSize - 64 * 1024;
s.Clear(128 * 1024);
}
using (SparseStream s = ntfs.OpenFile("file.bin", FileMode.Open))
{
Assert.Equal(fileSize + 64 * 1024, s.Length);
List <StreamExtent> extents = new List <StreamExtent>(s.Extents);
Assert.Equal(2, extents.Count);
Assert.Equal(0, extents[0].Start);
Assert.Equal(64 * 1024, extents[0].Length);
Assert.Equal((64 + 128) * 1024, extents[1].Start);
Assert.Equal(fileSize - (64 * 1024) - ((64 + 128) * 1024), extents[1].Length);
s.Position = 72 * 1024;
s.WriteByte(99);
byte[] readBuffer = new byte[fileSize];
s.Position = 0;
s.Read(readBuffer, 0, fileSize);
for (int i = 64 * 1024; i < (128 + 64) * 1024; ++i)
{
data[i] = 0;
}
for (int i = fileSize - (64 * 1024); i < fileSize; ++i)
{
data[i] = 0;
}
data[72 * 1024] = 99;
Assert.Equal(data, readBuffer);
}
}
public override DiscUtils.FileSystemInfo[] Detect(Stream stream, VolumeInfo volume)
{
if (NtfsFileSystem.Detect(stream))
{
return(new DiscUtils.FileSystemInfo[] { new VfsFileSystemInfo("NTFS", "Microsoft NTFS", Open) });
}
return(new DiscUtils.FileSystemInfo[0]);
}
public void Format_LargeDisk()
{
long size = 1024L * 1024 * 1024L * 1024; // 1 TB
SparseMemoryStream partStream = new SparseMemoryStream();
NtfsFileSystem.Format(partStream, "New Partition", Geometry.FromCapacity(size), 0, size / 512);
NtfsFileSystem ntfs = new NtfsFileSystem(partStream);
ntfs.Dump(TextWriter.Null, "");
}
public void GetAlternateDataStreams()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
ntfs.OpenFile("AFILE.TXT", FileMode.Create).Dispose();
Assert.Equal(0, ntfs.GetAlternateDataStreams("AFILE.TXT").Length);
ntfs.OpenFile("AFILE.TXT:ALTSTREAM", FileMode.Create).Dispose();
Assert.Equal(1, ntfs.GetAlternateDataStreams("AFILE.TXT").Length);
Assert.Equal("ALTSTREAM", ntfs.GetAlternateDataStreams("AFILE.TXT")[0]);
}
public void Format_SmallDisk()
{
long size = 8 * 1024 * 1024;
SparseMemoryStream partStream = new SparseMemoryStream();
//VirtualDisk disk = Vhd.Disk.InitializeDynamic(partStream, Ownership.Dispose, size);
NtfsFileSystem.Format(partStream, "New Partition", Geometry.FromCapacity(size), 0, size / 512);
NtfsFileSystem ntfs = new NtfsFileSystem(partStream);
ntfs.Dump(TextWriter.Null, "");
}
private static void CreateVirtualDisk(string filePath, int size)
{
using (FileStream fsStream = File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (VirtualDisk disk = DiscUtils.Vhd.Disk.InitializeDynamic(fsStream, DiscUtils.Streams.Ownership.Dispose, size * 1024 * 1024))
{
GuidPartitionTable.Initialize(disk, WellKnownPartitionType.WindowsNtfs);
PhysicalVolumeInfo volume = VolumeManager.GetPhysicalVolumes(disk)[0];
NtfsFileSystem.Format(volume, "CryptoBox");
}
}
public void ReparsePoints_NonEmpty()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
ntfs.CreateDirectory("dir");
ntfs.SetReparsePoint("dir", new ReparsePoint(123, new byte[] { 4, 5, 6 }));
ReparsePoint rp = ntfs.GetReparsePoint("dir");
Assert.Equal(123, rp.Tag);
Assert.NotNull(rp.Content);
Assert.Equal(3, rp.Content.Length);
}
public void DeleteShortNameDir()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
ntfs.CreateDirectory(@"\TestLongName1\TestLongName2");
ntfs.SetShortName(@"\TestLongName1\TestLongName2", "TESTLO~1");
Assert.True(ntfs.DirectoryExists(@"\TestLongName1\TESTLO~1"));
Assert.True(ntfs.DirectoryExists(@"\TestLongName1\TestLongName2"));
ntfs.DeleteDirectory(@"\TestLongName1", true);
Assert.False(ntfs.DirectoryExists(@"\TestLongName1"));
}
private void CreateDisk(string targetFilePath, long size, string diskLabel)
{
// Create the disk
using (var vhdStream = File.Create(targetFilePath))
{
var disk = Disk.InitializeDynamic(vhdStream, Ownership.None, size);
BiosPartitionTable.Initialize(disk, WellKnownPartitionType.WindowsNtfs);
using (var fs = NtfsFileSystem.Format(new VolumeManager(disk).GetLogicalVolumes()[0], diskLabel))
{
//fs.CreateDirectory(@"TestDir\CHILD");
// do other things with the file system...
}
}
}
/// <summary>
/// Creates a temporary vhd of the given size in GB.
/// The created VHD is dynamically allocated and is of type VHD (legacy)
/// </summary>
/// <param name="sizeInGB">The size of the VHD in GB</param>
/// <returns>The path to the created vhd</returns>
internal static string CreateVirtualDisk(long sizeInGB = 10)
{
long diskSize = sizeInGB * 1024 * 1024 * 1024;
string tempVhd = Path.GetTempFileName();
using Stream vhdStream = File.Create(tempVhd);
using Disk disk = Disk.InitializeDynamic(vhdStream, DiscUtils.Streams.Ownership.Dispose, diskSize);
BiosPartitionTable table = BiosPartitionTable.Initialize(disk, WellKnownPartitionType.WindowsNtfs);
PartitionInfo ntfsPartition = table.Partitions[0];
NtfsFileSystem.Format(ntfsPartition.Open(), "Windows UUP Medium", Geometry.FromCapacity(diskSize), ntfsPartition.FirstSector, ntfsPartition.SectorCount);
return(tempVhd);
}
public static DiscFileSystem GetFileSystem(Stream stream)
{
if (NtfsFileSystem.Detect(stream))
{
Logger.Verbose("Loading stream as <NTFS> file system");
return(new NtfsFileSystem(stream));
}
/* if (FatFileSystem.Detect(stream))
* {
* Logger.Verbose("Loading stream as <FAT> file system");
* return new FatFileSystem(stream);
* } */
return(null);
}
public void HasHardLink()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
using (Stream s = ntfs.OpenFile("ALongFileName.txt", FileMode.CreateNew)) { }
Assert.False(ntfs.HasHardLinks("ALongFileName.txt"));
ntfs.CreateHardLink("ALongFileName.txt", "AHardLink.TXT");
Assert.True(ntfs.HasHardLinks("ALongFileName.txt"));
using (Stream s = ntfs.OpenFile("ALongFileName2.txt", FileMode.CreateNew)) { }
// If we enumerate short names, then the initial long name results in two 'hardlinks'
ntfs.NtfsOptions.HideDosFileNames = false;
Assert.True(ntfs.HasHardLinks("ALongFileName2.txt"));
}
public void ExtentInfo()
{
using (SparseMemoryStream ms = new SparseMemoryStream())
{
Geometry diskGeometry = Geometry.FromCapacity(30 * 1024 * 1024);
NtfsFileSystem ntfs = NtfsFileSystem.Format(ms, "", diskGeometry, 0, diskGeometry.TotalSectorsLong);
// Check non-resident attribute
using (Stream s = ntfs.OpenFile(@"file", FileMode.Create, FileAccess.ReadWrite))
{
byte[] data = new byte[(int)ntfs.ClusterSize];
data[0] = 0xAE;
data[1] = 0x3F;
data[2] = 0x8D;
s.Write(data, 0, (int)ntfs.ClusterSize);
}
var extents = ntfs.PathToExtents("file");
Assert.Equal(1, extents.Length);
Assert.Equal(ntfs.ClusterSize, extents[0].Length);
ms.Position = extents[0].Start;
Assert.Equal(0xAE, ms.ReadByte());
Assert.Equal(0x3F, ms.ReadByte());
Assert.Equal(0x8D, ms.ReadByte());
// Check resident attribute
using (Stream s = ntfs.OpenFile(@"file2", FileMode.Create, FileAccess.ReadWrite))
{
s.WriteByte(0xBA);
s.WriteByte(0x82);
s.WriteByte(0x2C);
}
extents = ntfs.PathToExtents("file2");
Assert.Equal(1, extents.Length);
Assert.Equal(3, extents[0].Length);
byte[] read = new byte[100];
ms.Position = extents[0].Start;
ms.Read(read, 0, 100);
Assert.Equal(0xBA, read[0]);
Assert.Equal(0x82, read[1]);
Assert.Equal(0x2C, read[2]);
}
}
public static bool IsStreamSupportedFileSystem(Stream stream)
{
if (NtfsFileSystem.Detect(stream))
{
Logger.Verbose("Detected stream as <NTFS> file system");
return(true);
}
/* if (FatFileSystem.Detect(stream))
* {
* Logger.Verbose("Detected stream as <FAT> file-system");
* return true;
* } */
// only NTFS can be detected and formatted right now
return(false);
}
public void HardLinkCount()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
using (Stream s = ntfs.OpenFile("ALongFileName.txt", FileMode.CreateNew)) { }
Assert.Equal(1, ntfs.GetHardLinkCount("ALongFileName.txt"));
ntfs.CreateHardLink("ALongFileName.txt", "AHardLink.TXT");
Assert.Equal(2, ntfs.GetHardLinkCount("ALongFileName.txt"));
ntfs.CreateDirectory("DIR");
ntfs.CreateHardLink(@"ALongFileName.txt", @"DIR\SHORTLNK.TXT");
Assert.Equal(3, ntfs.GetHardLinkCount("ALongFileName.txt"));
// If we enumerate short names, then the initial long name results in two 'hardlinks'
ntfs.NtfsOptions.HideDosFileNames = false;
Assert.Equal(4, ntfs.GetHardLinkCount("ALongFileName.txt"));
}
public void AclInheritance()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
RawSecurityDescriptor sd = new RawSecurityDescriptor("O:BAG:BAD:(A;OICINP;GA;;;BA)");
ntfs.CreateDirectory("dir");
ntfs.SetSecurity("dir", sd);
ntfs.CreateDirectory(@"dir\subdir");
RawSecurityDescriptor inheritedSd = ntfs.GetSecurity(@"dir\subdir");
Assert.NotNull(inheritedSd);
Assert.Equal("O:BAG:BAD:(A;ID;GA;;;BA)", inheritedSd.GetSddlForm(AccessControlSections.All));
using (ntfs.OpenFile(@"dir\subdir\file", FileMode.Create, FileAccess.ReadWrite)) { }
inheritedSd = ntfs.GetSecurity(@"dir\subdir\file");
Assert.NotNull(inheritedSd);
Assert.Equal("O:BAG:BAD:", inheritedSd.GetSddlForm(AccessControlSections.All));
}
public void MoveLongName()
{
NtfsFileSystem ntfs = FileSystemSource.NtfsFileSystem();
using (Stream s = ntfs.OpenFile("ALongFileName.txt", FileMode.CreateNew)) { }
Assert.True(ntfs.FileExists("ALONGF~1.TXT"));
ntfs.MoveFile("ALongFileName.txt", "ADifferentLongFileName.txt");
Assert.False(ntfs.FileExists("ALONGF~1.TXT"));
Assert.True(ntfs.FileExists("ADIFFE~1.TXT"));
ntfs.CreateDirectory("ALongDirectoryName");
Assert.True(ntfs.DirectoryExists("ALONGD~1"));
ntfs.MoveDirectory("ALongDirectoryName", "ADifferentLongDirectoryName");
Assert.False(ntfs.DirectoryExists("ALONGD~1"));
Assert.True(ntfs.DirectoryExists("ADIFFE~1"));
}
/// <summary>
/// Creates local VHD files, using the parameters specified.
/// </summary>
/// <param name="isDynamic">True to create a dynamic VHD, False to create a fixed VHD.</param>
/// <param name="diskSizeInGb">Size of the VHD in gigabytes.</param>
/// <param name="filePath">Path of the VHD file.</param>
/// <param name="diskName">Name of the volume of the VHD.</param>
public static void CreateVhdDisk(bool isDynamic, int diskSizeInGb, string filePath, string diskName)
{
var diskSize = (long)ByteSize.FromGigaBytes(diskSizeInGb).Bytes;
using (var fs = new FileStream(filePath, FileMode.OpenOrCreate))
{
using (VirtualDisk destDisk = isDynamic ? Disk.InitializeDynamic(fs, Ownership.None, diskSize)
: Disk.InitializeFixed(fs, Ownership.None, diskSize))
{
BiosPartitionTable.Initialize(destDisk, WellKnownPartitionType.WindowsNtfs);
var volumeManager = new VolumeManager(destDisk);
using (var destNtfs = NtfsFileSystem.Format(volumeManager.GetLogicalVolumes().FirstOrDefault(), diskName, new NtfsFormatOptions()))
{
destNtfs.NtfsOptions.ShortNameCreation = ShortFileNameOption.Disabled;
}
}
fs.Flush(); // commit everything to the stream before closing
}
}
