/// <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);
}
}
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 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 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 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 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");
}
}
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 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]);
}
}
/// <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
}
}
// Extension method to handle partition formatting
private static DiscFileSystem FormatPartition(this VirtualDisk Disk, int PartitionIndex)
{
var type = GetPartitionType(Disk.Partitions[PartitionIndex]);
switch (type)
{
case WellKnownPartitionType.WindowsFat:
return(FatFileSystem.FormatPartition(Disk, PartitionIndex, null));
case WellKnownPartitionType.WindowsNtfs:
return(NtfsFileSystem.Format(Disk.Partitions[PartitionIndex].Open(), null, Disk.Geometry,
Disk.Partitions[PartitionIndex].FirstSector,
Disk.Partitions[PartitionIndex].SectorCount));
case WellKnownPartitionType.Linux:
// return ExtFileSystem.Format(...);
default:
return(null);
}
}
protected override void DoRun()
{
if (DiskSize <= 0)
{
DisplayHelp();
return;
}
using (VirtualDisk sourceDisk = VirtualDisk.OpenDisk(_sourceFile.Value, FileAccess.Read, UserName, Password))
using (VirtualDisk destDisk = VirtualDisk.CreateDisk(OutputDiskType, OutputDiskVariant, _destFile.Value, DiskParameters, UserName, Password))
{
if (destDisk is DiscUtils.Vhd.Disk)
{
((DiscUtils.Vhd.Disk)destDisk).AutoCommitFooter = false;
}
// Copy the MBR from the source disk, and invent a new signature for this new disk
destDisk.SetMasterBootRecord(sourceDisk.GetMasterBootRecord());
destDisk.Signature = new Random().Next();
SparseStream sourcePartStream = SparseStream.FromStream(sourceDisk.Partitions[0].Open(), Ownership.None);
NtfsFileSystem sourceNtfs = new NtfsFileSystem(sourcePartStream);
// Copy the OS boot code into memory, so we can apply it when formatting the new disk
byte[] bootCode;
using (Stream bootStream = sourceNtfs.OpenFile("$Boot", FileMode.Open, FileAccess.Read))
{
bootCode = new byte[bootStream.Length];
int totalRead = 0;
while (totalRead < bootCode.Length)
{
totalRead += bootStream.Read(bootCode, totalRead, bootCode.Length - totalRead);
}
}
// Partition the new disk with a single NTFS partition
BiosPartitionTable.Initialize(destDisk, WellKnownPartitionType.WindowsNtfs);
VolumeManager volMgr = new VolumeManager(destDisk);
string label = _labelSwitch.IsPresent ? _labelSwitch.Value : sourceNtfs.VolumeLabel;
using (NtfsFileSystem destNtfs = NtfsFileSystem.Format(volMgr.GetLogicalVolumes()[0], label, bootCode))
{
destNtfs.SetSecurity(@"\", sourceNtfs.GetSecurity(@"\"));
destNtfs.NtfsOptions.ShortNameCreation = ShortFileNameOption.Disabled;
sourceNtfs.NtfsOptions.HideHiddenFiles = false;
sourceNtfs.NtfsOptions.HideSystemFiles = false;
CopyFiles(sourceNtfs, destNtfs, @"\", true);
if (destNtfs.FileExists(@"\boot\BCD"))
{
// Force all boot entries in the BCD to point to the newly created NTFS partition - does _not_ cope with
// complex multi-volume / multi-boot scenarios at all.
using (Stream bcdStream = destNtfs.OpenFile(@"\boot\BCD", FileMode.Open, FileAccess.ReadWrite))
{
using (RegistryHive hive = new RegistryHive(bcdStream))
{
Store store = new Store(hive.Root);
foreach (var obj in store.Objects)
{
foreach (var elem in obj.Elements)
{
if (elem.Format == DiscUtils.BootConfig.ElementFormat.Device)
{
elem.Value = DiscUtils.BootConfig.ElementValue.ForDevice(elem.Value.ParentObject, volMgr.GetPhysicalVolumes()[0]);
}
}
}
}
}
}
}
}
}
