public void Properties_Work()
{
using (Stream stream = File.OpenRead("TestAssets/ipod-fat32.dmg"))
using (DiskImageFile file = new DiskImageFile(stream, Ownership.None))
{
var buffer = file.Buffer;
Assert.Equal(2, buffer.Blocks.Count);
Assert.True(buffer.CanRead);
Assert.False(buffer.CanWrite);
Assert.Equal(0x2107e00, buffer.Capacity);
}
}
public void ConstructorFromFiles()
{
MemoryStream baseStream = new MemoryStream();
DiskImageFile baseFile = DiskImageFile.InitializeDynamic(baseStream, Ownership.Dispose, 16 * 1024L * 1024 * 1024);
MemoryStream childStream = new MemoryStream();
DiskImageFile childFile = DiskImageFile.InitializeDifferencing(childStream, Ownership.Dispose, baseFile, @"C:\temp\foo.vhd", @".\foo.vhd", DateTime.Now);
MemoryStream grandChildStream = new MemoryStream();
DiskImageFile grandChildFile = DiskImageFile.InitializeDifferencing(grandChildStream, Ownership.Dispose, childFile, @"C:\temp\child1.vhd", @".\child1.vhd", DateTime.Now);
using (Disk disk = new Disk(new DiskImageFile[] { grandChildFile, childFile, baseFile }, Ownership.Dispose))
{
Assert.NotNull(disk.Content);
}
}
public void InitializeDifferencing()
{
MemoryStream baseStream = new MemoryStream();
MemoryStream diffStream = new MemoryStream();
DiskImageFile baseFile = DiskImageFile.InitializeDynamic(baseStream, Ownership.Dispose, 16 * 1024L * 1024 * 1024);
using (Disk disk = Disk.InitializeDifferencing(diffStream, Ownership.None, baseFile, Ownership.Dispose, @"C:\TEMP\Base.vhd", @".\Base.vhd", DateTime.UtcNow))
{
Assert.NotNull(disk);
Assert.True(disk.Geometry.Capacity > 15.8 * 1024L * 1024 * 1024 && disk.Geometry.Capacity <= 16 * 1024L * 1024 * 1024);
Assert.True(disk.Geometry.Capacity == baseFile.Geometry.Capacity);
Assert.Equal(2, new List <VirtualDiskLayer>(disk.Layers).Count);
}
Assert.True(1 * 1024 * 1024 > diffStream.Length);
diffStream.Dispose();
}
public void InitializeDifferencingRelPath()
{
DiscFileSystem fs = new InMemoryFileSystem();
DiskImageFile baseFile = DiskImageFile.Initialize(fs, @"\dir\subdir\base.vmdk", 16 * 1024L * 1024 * 1024, DiskCreateType.MonolithicSparse);
using (Disk disk = Disk.InitializeDifferencing(fs, @"\dir\diff.vmdk", DiskCreateType.MonolithicSparse, @"subdir\base.vmdk"))
{
Assert.NotNull(disk);
Assert.True(disk.Geometry.Capacity > 15.8 * 1024L * 1024 * 1024 && disk.Geometry.Capacity < 16 * 1024L * 1024 * 1024);
Assert.True(disk.Content.Length == 16 * 1024L * 1024 * 1024);
Assert.Equal(2, new List <VirtualDiskLayer>(disk.Layers).Count);
}
Assert.True(fs.GetFileLength(@"\dir\diff.vmdk") > 2 * 1024 * 1024);
Assert.True(fs.GetFileLength(@"\dir\diff.vmdk") < 4 * 1024 * 1024);
}
public void InitializeDifferencing()
{
MemoryStream baseStream = new MemoryStream();
MemoryStream diffStream = new MemoryStream();
using (DiskImageFile baseFile = DiskImageFile.InitializeDynamic(baseStream, Ownership.Dispose, 16 * 1024L * 1024 * 1024))
{
using (DiskImageFile diffFile = DiskImageFile.InitializeDifferencing(diffStream, Ownership.None, baseFile, @"C:\TEMP\Base.vhd", @".\Base.vhd", new DateTime(2007, 12, 31)))
{
Assert.NotNull(diffFile);
Assert.True(diffFile.Geometry.Capacity > 15.8 * 1024L * 1024 * 1024 && diffFile.Geometry.Capacity < 16 * 1024L * 1024 * 1024);
Assert.True(diffFile.IsSparse);
Assert.NotEqual(diffFile.CreationTimestamp, new DateTime(2007, 12, 31));
}
}
Assert.True(1 * 1024 * 1024 > diffStream.Length);
}
static void Main(string[] args)
{
string cvtPathFilename;
string outPathFilename;
bool ignoreFileSignature;
try
{
ParseCommandLineArgs(args, out cvtPathFilename, out outPathFilename, out ignoreFileSignature);
byte[] imageData = DiskImageFile.ReadCvtFile(cvtPathFilename);
CleanCvt(imageData, outPathFilename, ignoreFileSignature);
}
catch (Exception e)
{
Console.WriteLine(e.Message.ToString());
ShowUsageMsg();
}
//Console.ReadKey();
}
public void Lvm2VhdxZip()
{
SetupHelper.SetupComplete();
using (FileStream fs = File.OpenRead(Path.Combine("..", "..", "..", "Lvm", "Data", "lvm2.zip")))
using (Stream vhdx = ZipUtilities.ReadFileFromZip(fs))
using (var diskImage = new DiskImageFile(vhdx, Ownership.Dispose))
using (var disk = new Disk(new List <DiskImageFile> {
diskImage
}, Ownership.Dispose))
{
var manager = new VolumeManager(disk);
var logicalVolumes = manager.GetLogicalVolumes();
Assert.Equal(3, logicalVolumes.Length);
Assert.Equal(1283457024, logicalVolumes[0].Length);
Assert.Equal(746586112, logicalVolumes[1].Length);
Assert.Equal(1178599424, logicalVolumes[2].Length);
}
}
public void FooterMissing()
{
//
// Simulates a partial failure extending the file, that the file footer is corrupt - should read start of the file instead.
//
Geometry geometry;
MemoryStream stream = new MemoryStream();
using (DiskImageFile file = DiskImageFile.InitializeDynamic(stream, Ownership.None, 16 * 1024L * 1024 * 1024))
{
geometry = file.Geometry;
}
stream.SetLength(stream.Length - 512);
using (DiskImageFile file = new DiskImageFile(stream))
{
Assert.Equal(geometry, file.Geometry);
}
}
public void InitializeDifferencing()
{
DiscFileSystem fs = new InMemoryFileSystem();
DiskImageFile baseFile = DiskImageFile.Initialize(fs, @"\base\base.vmdk", 16 * 1024L * 1024 * 1024, DiskCreateType.MonolithicSparse);
using (Disk disk = Disk.InitializeDifferencing(fs, @"\diff\diff.vmdk", DiskCreateType.MonolithicSparse, @"\base\base.vmdk"))
{
Assert.NotNull(disk);
Assert.True(disk.Geometry.Capacity > 15.8 * 1024L * 1024 * 1024 && disk.Geometry.Capacity < 16 * 1024L * 1024 * 1024);
Assert.True(disk.Content.Length == 16 * 1024L * 1024 * 1024);
Assert.Equal(2, new List <VirtualDiskLayer>(disk.Layers).Count);
List <DiskImageFile> links = new List <DiskImageFile>(disk.Links);
Assert.Equal(2, links.Count);
List <string> paths = new List <string>(links[0].ExtentPaths);
Assert.Equal(1, paths.Count);
Assert.Equal("diff.vmdk", paths[0]);
}
Assert.True(fs.GetFileLength(@"\diff\diff.vmdk") > 2 * 1024 * 1024);
Assert.True(fs.GetFileLength(@"\diff\diff.vmdk") < 4 * 1024 * 1024);
}
/// <summary>
/// Initializes a new instance of the Disk class.
/// </summary>
/// <param name="file">The file containing the disk image.</param>
public Disk(DiskImageFile file)
{
_diskImage = file;
}
static void CleanCvt(byte[] cvtData, string outPathFilename, bool ignoreFileSignature)
{
byte[] cleanCvt = GEOSDisk.GetCleanCvtFromCvt(cvtData, ignoreFileSignature);
DiskImageFile.WriteFile(cleanCvt, outPathFilename);
}
static void ShowDir(string imagePathFilename)
{
byte[] bamBlock;
ArrayList dirEntryList = new ArrayList();
//string imagePathFilename = @"free.d64";
byte[] imageData = DiskImageFile.ReadFile(imagePathFilename);
int imageDataType = DiskImageFile.GetImageDataType(imagePathFilename);
bamBlock = DOSDisk.ReadBAMBlock(imageData, imageDataType);
Console.Write("0 \"{0}\" {1} {2}"
, Core.ConvertPETSCII2ASCII(DOSDisk.GetDiskName(bamBlock, imageDataType))
, Core.ConvertPETSCII2ASCII(DOSDisk.GetDiskID(bamBlock, imageDataType))
, Core.ConvertPETSCII2ASCII(DOSDisk.GetDOSType(bamBlock, imageDataType)));
Console.Write(" ");
Console.Write("|{0}", "DirIndex");
Console.Write("|{0}", " GEOS ");
Console.Write("|{0}", "MD5");
Console.WriteLine();
dirEntryList = DOSDisk.GetDirEntryList(bamBlock, imageData, imageDataType);
int dirIndex = 0;
foreach (byte[] de in dirEntryList)
{
dirIndex++;
if (!DOSDisk.IsDirEntryEmpty(de))
{
string filename = Core.ConvertPETSCII2ASCII(DOSDisk.GetFilename(de));
Console.Write("{0,-5}\"{1}\"{2}{3}{4}{5}"
, DOSDisk.GetFileSizeInBlocks(de).ToString()
, filename
, Core.ConvertPETSCII2ASCII(DOSDisk.GetPartAfterFilename(de))
, DOSDisk.GetSplatFileSign(de)
, DOSDisk.GetFileTypeExt(de)
, DOSDisk.GetLockFlagSign(de)
);
Console.Write(" ");
Console.Write("|{0,8}", dirIndex.ToString());
Console.Write("|{0} {1}"
, (GEOSDisk.IsGeosFile(de) ? GEOSDisk.GetGEOSFiletypeName(de) : " ")
, (GEOSDisk.IsGeosFile(de) ? GEOSDisk.GetGEOSFileStructureName(de) : " ")
);
Console.Write("|{0}"
, DOSDisk.GetMD5ByCBMFile(de, imageData, imageDataType)
);
Console.WriteLine();
//if (GEOSDisk.IsGeosFile(de))
//{
// DiskImageFile.WriteCVTFile(de, imagePathFilename, filename);
//}
//else
//{
// DiskImageFile.WriteFileBlockChain(de[1], de[2], imagePathFilename, filename);
//}
}
}
Console.WriteLine("{0} BLOCKS FREE."
, DOSDisk.GetFreeBlocks(bamBlock).ToString()
);
}
protected override void DoRun()
{
using (DiskImageFile vhdxFile = new DiskImageFile(_vhdxFile.Value, FileAccess.Read))
{
DiskImageFileInfo info = vhdxFile.Information;
FileInfo fileInfo = new FileInfo(_vhdxFile.Value);
Console.WriteLine("File Info");
Console.WriteLine("---------");
Console.WriteLine(" File Name: {0}", fileInfo.FullName);
Console.WriteLine(" File Size: {0} ({1} bytes)", Utilities.ApproximateDiskSize(fileInfo.Length), fileInfo.Length);
Console.WriteLine(" File Creation Time: {0} (UTC)", fileInfo.CreationTimeUtc);
Console.WriteLine(" File Write Time: {0} (UTC)", fileInfo.LastWriteTimeUtc);
Console.WriteLine();
Console.WriteLine("VHDX File Info");
Console.WriteLine("--------------");
Console.WriteLine(" Signature: {0:x8}", info.Signature);
Console.WriteLine(" Creator: {0:x8}", info.Creator);
Console.WriteLine(" Block Size: {0} (0x{0:X8})", info.BlockSize);
Console.WriteLine("Leave Blocks Alloced: {0}", info.LeaveBlocksAllocated);
Console.WriteLine(" Has Parent: {0}", info.HasParent);
Console.WriteLine(" Disk Size: {0} ({1} (0x{1:X8}))", Utilities.ApproximateDiskSize(info.DiskSize), info.DiskSize);
Console.WriteLine(" Logical Sector Size: {0} (0x{0:X8})", info.LogicalSectorSize);
Console.WriteLine("Physical Sector Size: {0} (0x{0:X8})", info.PhysicalSectorSize);
Console.WriteLine(" Parent Locator Type: {0}", info.ParentLocatorType);
WriteParentLocations(info);
Console.WriteLine();
WriteHeaderInfo(info.FirstHeader);
WriteHeaderInfo(info.SecondHeader);
if (info.ActiveHeader.LogGuid != Guid.Empty)
{
Console.WriteLine("Log Info (Active Sequence)");
Console.WriteLine("--------------------------");
foreach (var entry in info.ActiveLogSequence)
{
Console.WriteLine(" Log Entry");
Console.WriteLine(" ---------");
Console.WriteLine(" Sequence Number: {0}", entry.SequenceNumber);
Console.WriteLine(" Tail: {0}", entry.Tail);
Console.WriteLine(" Flushed File Offset: {0} (0x{0:X8})", entry.FlushedFileOffset);
Console.WriteLine(" Last File Offset: {0} (0x{0:X8})", entry.LastFileOffset);
Console.WriteLine(" File Extents: {0}", entry.IsEmpty ? "<none>" : "");
foreach (var extent in entry.ModifiedExtents)
{
Console.WriteLine(" {0} +{1} (0x{0:X8} +0x{1:X8})", extent.Offset, extent.Count);
}
Console.WriteLine();
}
}
RegionTableInfo regionTable = info.RegionTable;
Console.WriteLine("Region Table Info");
Console.WriteLine("-----------------");
Console.WriteLine(" Signature: {0}", regionTable.Signature);
Console.WriteLine(" Checksum: {0:x8}", regionTable.Checksum);
Console.WriteLine(" Entry Count: {0}", regionTable.Count);
Console.WriteLine();
foreach (var entry in regionTable)
{
Console.WriteLine("Region Table Entry Info");
Console.WriteLine("-----------------------");
Console.WriteLine(" Guid: {0}", entry.Guid);
Console.WriteLine(" Well-Known Name: {0}", entry.WellKnownName);
Console.WriteLine(" File Offset: {0} (0x{0:X8})", entry.FileOffset);
Console.WriteLine(" Length: {0} (0x{0:X8})", entry.Length);
Console.WriteLine(" Is Required: {0}", entry.IsRequired);
Console.WriteLine();
}
MetadataTableInfo metadataTable = info.MetadataTable;
Console.WriteLine("Metadata Table Info");
Console.WriteLine("-------------------");
Console.WriteLine(" Signature: {0}", metadataTable.Signature);
Console.WriteLine(" Entry Count: {0}", metadataTable.Count);
Console.WriteLine();
foreach (var entry in metadataTable)
{
Console.WriteLine("Metadata Table Entry Info");
Console.WriteLine("-------------------------");
Console.WriteLine(" Item Id: {0}", entry.ItemId);
Console.WriteLine(" Well-Known Name: {0}", entry.WellKnownName);
Console.WriteLine(" Offset: {0} (0x{0:X8})", entry.Offset);
Console.WriteLine(" Length: {0} (0x{0:X8})", entry.Length);
Console.WriteLine(" Is User: {0}", entry.IsUser);
Console.WriteLine(" Is Required: {0}", entry.IsRequired);
Console.WriteLine(" Is Virtual Disk: {0}", entry.IsVirtualDisk);
Console.WriteLine();
}
}
}
private void doOpenFile(string fileName)
{
listView1.Items.Clear();
textBoxInfoText.Text = "";
string[] MP3FileArray =
{
"StartMP3_64",
"StartMP64.1",
"StartMP64.2",
"StartMP64.3",
"StartMP64.4",
"StartMP64.5",
"StartMP3_128",
"StartMP128.1",
"StartMP128.2",
"StartMP128.3",
"StartMP128.4",
"StartMP128.5"
};
listView1.Columns[0].TextAlign = HorizontalAlignment.Right;
string imagePathFilename = fileName;
byte[] bamBlock;
ArrayList dirEntryList = new ArrayList();
byte[] imageData = DiskImageFile.ReadFile(imagePathFilename);
String md5 = Core.GetMD5Hash(imageData);
textBoxFilename.Text = fileName + " MD5:" + md5;
int imageDataType = DiskImageFile.GetImageDataType(imagePathFilename);
bamBlock = DOSDisk.ReadBAMBlock(imageData, imageDataType);
textBoxDiskLabel.Text = String.Format("0 \"{0}\" {1} {2}"
, Core.ConvertPETSCII2ASCII(DOSDisk.GetDiskName(bamBlock, imageDataType))
, Core.ConvertPETSCII2ASCII(DOSDisk.GetDiskID(bamBlock, imageDataType))
, Core.ConvertPETSCII2ASCII(DOSDisk.GetDOSType(bamBlock, imageDataType)));
dirEntryList = DOSDisk.GetDirEntryList(bamBlock, imageData, imageDataType);
textBoxInfoText.Text += "{|class=\"wikitable\"" + Environment.NewLine;
textBoxInfoText.Text += "|" + Environment.NewLine;
textBoxInfoText.Text += "{|" + Environment.NewLine;
textBoxInfoText.Text += "| '''Imagedatei'''" + Environment.NewLine;
textBoxInfoText.Text += "| ''':'''" + Environment.NewLine;
textBoxInfoText.Text += "|" + Path.GetFileName(imagePathFilename) + Environment.NewLine;
textBoxInfoText.Text += "|-" + Environment.NewLine;
textBoxInfoText.Text += "|'''Imagedatei MD5'''" + Environment.NewLine;
textBoxInfoText.Text += "|''':'''" + Environment.NewLine;
textBoxInfoText.Text += "|" + md5 + Environment.NewLine;
textBoxInfoText.Text += "|-" + Environment.NewLine;
textBoxInfoText.Text += "|'''Quelle'''" + Environment.NewLine;
textBoxInfoText.Text += "|''':'''" + Environment.NewLine;
textBoxInfoText.Text += "|" + Environment.NewLine;
textBoxInfoText.Text += "|}" + Environment.NewLine;
textBoxInfoText.Text += "{| class=\"wikitable sortable\"" + Environment.NewLine;
textBoxInfoText.Text += "!Nr." + Environment.NewLine;
textBoxInfoText.Text += "!Datei" + Environment.NewLine;
textBoxInfoText.Text += "!style=\"text-align:right\"|Größe" + Environment.NewLine;
textBoxInfoText.Text += "!MD5" + Environment.NewLine;
textBoxInfoText.Text += "!Info" + Environment.NewLine;
int dirIndex = 0;
foreach (byte[] de in dirEntryList)
{
dirIndex++;
if (!DOSDisk.IsDirEntryEmpty(de))
{
String[] colText =
{
Core.ConvertPETSCII2ASCII(DOSDisk.GetFilename(de)) + Core.ConvertPETSCII2ASCII(DOSDisk.GetPartAfterFilename(de)),
DOSDisk.GetFileSizeInBlocks(de).ToString(),
DOSDisk.GetSplatFileSign(de),
DOSDisk.GetFileTypeExt(de),
DOSDisk.GetLockFlagSign(de),
dirIndex.ToString(),
(GEOSDisk.IsGeosFile(de) ? GEOSDisk.GetGEOSFiletypeName(de) : " "),
(GEOSDisk.IsGeosFile(de) ? GEOSDisk.GetGEOSFileStructureName(de) : " "),
DOSDisk.GetMD5ByCBMFile(de, imageData, imageDataType),
DOSDisk.GetInfoTextByMP3File(de, imageData, imageDataType),
};
ListViewItem listViewItem = new ListViewItem(colText[0]); // first col
listViewItem.SubItems.Add(colText[1]);
listViewItem.SubItems.Add(colText[2]);
listViewItem.SubItems.Add(colText[3]);
listViewItem.SubItems.Add(colText[4]);
listViewItem.SubItems.Add(colText[5]);
listViewItem.SubItems.Add(colText[6]);
listViewItem.SubItems.Add(colText[7]);
listViewItem.SubItems.Add(colText[8]);
listViewItem.SubItems.Add(colText[9]);
listView1.Items.Add(listViewItem);
//textBoxInfoText.Text += String.Format("{0,-16} {1,5} {2,-32} {3}{4}", colText[0],colText[1],colText[8], colText[9],Environment.NewLine);
Boolean IsBold = MP3FileArray.Contains(colText[0].TrimEnd());
textBoxInfoText.Text += "|-" + Environment.NewLine;
textBoxInfoText.Text += "|" + dirIndex + Environment.NewLine;
if (IsBold)
{
textBoxInfoText.Text += "|'''" + colText[0].TrimEnd() + "'''" + Environment.NewLine;
}
else
{
textBoxInfoText.Text += "|" + colText[0].TrimEnd() + Environment.NewLine;
}
textBoxInfoText.Text += "|style = \"text-align:right\" |" + colText[1] + Environment.NewLine;
textBoxInfoText.Text += "|" + colText[8] + Environment.NewLine;
textBoxInfoText.Text += "|" + colText[9] + Environment.NewLine;
}
}
textBoxInfoText.Text += "|}" + Environment.NewLine;
textBoxInfoText.Text += "|}" + Environment.NewLine;
/*
* {|class="wikitable"
|
| {|
|'''Imagedatei'''
|''':'''
| MP3_64D.D81
|-
|'''Imagedatei MD5'''
|''':'''
| 93C4E05B0C50BBD6A4B6A9976FA6B35D
|-
|'''Quelle'''
|''':'''
|
|}
| {| class="wikitable sortable"
| !Datei
| !style="text-align:right"|Größe
| !MD5
| !Info
|-
|StartMP3_64
|style="text-align:right"|56
|9296FD29D63ED70733F943ACF7B4FD88
|BUILD:FULL-090100.2020 Deutsch C64
|}
|}
*/
}
static void ExtraxctFile(string imagePathFilename, int dirIndex, string asciiCbmFilename, string outPathFilename)
{
byte[] bamBlock;
byte[] dirEntry = null;
ArrayList dirEntryList = new ArrayList();
byte[] imageData = DiskImageFile.ReadFile(imagePathFilename);
int imageDataType = DiskImageFile.GetImageDataType(imagePathFilename);
bamBlock = DOSDisk.ReadBAMBlock(imageData, imageDataType);
dirEntryList = DOSDisk.GetDirEntryList(bamBlock, imageData, imageDataType);
// by DirIndex
if (dirIndex > 0)
{
dirEntry = (byte[])dirEntryList[dirIndex - 1];
}
else
{
if (asciiCbmFilename.Length > 0)
{
bool found = false;
foreach (byte[] de in dirEntryList)
{
if (Core.ConvertPETSCII2ASCII(DOSDisk.GetFilename(de)) == asciiCbmFilename)
{
if (!found)
{
dirEntry = de;
found = true;
}
else
{
throw new Exception("Filename is not unique!");
}
}
}
if (!found)
{
throw new Exception(String.Format("Filename {0} not found!", asciiCbmFilename));
}
}
else
{
throw new Exception("No file specified");
}
}
string filename = (Core.ConvertPETSCII2ASCII(DOSDisk.GetFilename(dirEntry)));
if (DOSDisk.GetFileType(dirEntry) == 0)
{
throw new Exception(String.Format("File {0} is deleted!", filename));
}
byte[] fileData = DOSDisk.getFileData(dirEntry, imageData, imageDataType);
if (outPathFilename != "")
{
DiskImageFile.WriteFile(fileData, outPathFilename);
}
else
{
DiskImageFile.WriteFile(fileData, filename);
}
}
/// <summary>
/// Initializes a new instance of the Disk class.
/// </summary>
/// <param name="file">The contents of the disk.</param>
private Disk(DiskImageFile file)
{
_file = file;
}
/// <summary>
/// Initializes a new instance of the Disk class.
/// </summary>
/// <param name="path">The path to the disk image</param>
/// <param name="access">The access requested to the disk</param>
public Disk(string path, FileAccess access)
{
FileShare share = (access == FileAccess.Read) ? FileShare.Read : FileShare.None;
_file = new DiskImageFile(new FileStream(path, FileMode.Open, access, share), Ownership.Dispose, null);
}
/// <summary>
/// Initializes a new instance of the Disk class.
/// </summary>
/// <param name="path">The path to the disk image</param>
public Disk(string path)
{
_file = new DiskImageFile(new FileStream(path, FileMode.Open, FileAccess.ReadWrite, FileShare.None), Ownership.Dispose, null);
}
/// <summary>
/// Initializes a new instance of the Disk class.
/// </summary>
/// <param name="stream">The stream to read</param>
/// <param name="ownsStream">Indicates if the new instance should control the lifetime of the stream.</param>
/// <param name="geometry">The emulated geometry of the disk.</param>
public Disk(Stream stream, Ownership ownsStream, Geometry geometry)
{
_file = new DiskImageFile(stream, ownsStream, geometry);
}
/// <summary>
/// Disposes of underlying resources.
/// </summary>
/// <param name="disposing">Set to <c>true</c> if called within Dispose(),
/// else <c>false</c>.</param>
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
if (_file != null)
{
_file.Dispose();
}
_file = null;
}
}
finally
{
base.Dispose(disposing);
}
}
protected override void DoRun()
{
if (!_dontCheck.IsPresent)
{
using (Stream s = new FileStream(_vhdFile.Value, FileMode.Open, FileAccess.Read))
{
FileChecker vhdChecker = new FileChecker(s);
if (!vhdChecker.Check(Console.Out, ReportLevels.All))
{
Console.WriteLine("Aborting: Invalid VHD file");
Environment.Exit(1);
}
}
}
using (DiskImageFile vhdFile = new DiskImageFile(_vhdFile.Value, FileAccess.Read))
{
DiskImageFileInfo info = vhdFile.Information;
FileInfo fileInfo = new FileInfo(_vhdFile.Value);
Console.WriteLine("File Info");
Console.WriteLine("---------");
Console.WriteLine(" File Name: {0}", fileInfo.FullName);
Console.WriteLine(" File Size: {0} bytes", fileInfo.Length);
Console.WriteLine(" File Creation Time: {0} (UTC)", fileInfo.CreationTimeUtc);
Console.WriteLine(" File Write Time: {0} (UTC)", fileInfo.LastWriteTimeUtc);
Console.WriteLine();
Console.WriteLine("Common Disk Info");
Console.WriteLine("-----------------");
Console.WriteLine(" Cookie: {0:x8}", info.Cookie);
Console.WriteLine(" Features: {0:x8}", info.Features);
Console.WriteLine(" File Format Version: {0}.{1}", ((info.FileFormatVersion >> 16) & 0xFFFF), (info.FileFormatVersion & 0xFFFF));
Console.WriteLine(" Creation Time: {0} (UTC)", info.CreationTimestamp);
Console.WriteLine(" Creator App: {0:x8}", info.CreatorApp);
Console.WriteLine(" Creator Version: {0}.{1}", ((info.CreatorVersion >> 16) & 0xFFFF), (info.CreatorVersion & 0xFFFF));
Console.WriteLine(" Creator Host OS: {0}", info.CreatorHostOS);
Console.WriteLine(" Original Size: {0} bytes", info.OriginalSize);
Console.WriteLine(" Current Size: {0} bytes", info.CurrentSize);
Console.WriteLine(" Geometry (C/H/S): {0}", info.Geometry);
Console.WriteLine(" Disk Type: {0}", info.DiskType);
Console.WriteLine(" Checksum: {0:x8}", info.FooterChecksum);
Console.WriteLine(" Unique Id: {0}", info.UniqueId);
Console.WriteLine(" Saved State: {0}", info.SavedState);
Console.WriteLine();
if (info.DiskType == FileType.Differencing || info.DiskType == FileType.Dynamic)
{
Console.WriteLine();
Console.WriteLine("Dynamic Disk Info");
Console.WriteLine("-----------------");
Console.WriteLine(" Cookie: {0}", info.DynamicCookie);
Console.WriteLine(" Header Version: {0}.{1}", ((info.DynamicHeaderVersion >> 16) & 0xFFFF), (info.DynamicHeaderVersion & 0xFFFF));
Console.WriteLine(" Block Count: {0}", info.DynamicBlockCount);
Console.WriteLine(" Block Size: {0} bytes", info.DynamicBlockSize);
Console.WriteLine(" Checksum: {0:x8}", info.DynamicChecksum);
Console.WriteLine(" Parent Unique Id: {0}", info.DynamicParentUniqueId);
Console.WriteLine(" Parent Write Time: {0} (UTC)", info.DynamicParentTimestamp);
Console.WriteLine(" Parent Name: {0}", info.DynamicParentUnicodeName);
Console.Write(" Parent Locations: ");
foreach (string parentLocation in info.DynamicParentLocators)
{
Console.Write("{0}\n ", parentLocation);
}
Console.WriteLine();
}
}
}
public DiskExtent(DiskImageFile file)
{
_file = file;
}
/// <summary>
/// Initializes a new instance of the Disk class. Differencing disks are not supported.
/// </summary>
/// <param name="stream">The stream to read</param>
public Disk(Stream stream)
{
_diskImage = new DiskImageFile(stream);
}
public DiskExtent(DiskImageFile file)
{
_file = file;
}
/// <summary>
/// Initializes a new instance of the Disk class. Differencing disks are not supported.
/// </summary>
/// <param name="stream">The stream to read</param>
/// <param name="ownsStream">Indicates if the new disk should take ownership of <paramref name="stream"/> lifetime.</param>
public Disk(Stream stream, Ownership ownsStream)
{
_diskImage = new DiskImageFile(stream, ownsStream);
}
