mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
848 lines
32 KiB
C#
848 lines
32 KiB
C#
// /***************************************************************************
|
|
// The Disc Image Chef
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : Partimage.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Component
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Description
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as
|
|
// published by the Free Software Foundation; either version 2.1 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2017 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using DiscImageChef.ImagePlugins;
|
|
using System.Linq;
|
|
using DiscImageChef.CommonTypes;
|
|
using DiscImageChef.Console;
|
|
using DiscImageChef.Filters;
|
|
using System.Text;
|
|
using Extents;
|
|
|
|
namespace DiscImageChef.DiscImages
|
|
{
|
|
public class Partimage : ImagePlugin
|
|
{
|
|
#region Internal constants
|
|
readonly byte[] PartimageMagic = { 0x50, 0x61, 0x52, 0x74, 0x49, 0x6D, 0x41, 0x67, 0x45, 0x2D, 0x56, 0x6F, 0x4C, 0x75, 0x4D, 0x65,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
const int MAX_DESCRIPTION = 4096;
|
|
const int MAX_HOSTNAMESIZE = 128;
|
|
const int MAX_DEVICENAMELEN = 512;
|
|
const int MAX_UNAMEINFOLEN = 65; //SYS_NMLN
|
|
const int MBR_SIZE_WHOLE = 512;
|
|
const int MAX_DESC_MODEL = 128;
|
|
const int MAX_DESC_GEOMETRY = 1024;
|
|
const int MAX_DESC_IDENTIFY = 4096;
|
|
const int CHECK_FREQUENCY = 65536;
|
|
readonly string MAGIC_BEGIN_LOCALHEADER = "MAGIC-BEGIN-LOCALHEADER";
|
|
readonly string MAGIC_BEGIN_DATABLOCKS = "MAGIC-BEGIN-DATABLOCKS";
|
|
readonly string MAGIC_BEGIN_BITMAP = "MAGIC-BEGIN-BITMAP";
|
|
readonly string MAGIC_BEGIN_MBRBACKUP = "MAGIC-BEGIN-MBRBACKUP";
|
|
readonly string MAGIC_BEGIN_TAIL = "MAGIC-BEGIN-TAIL";
|
|
readonly string MAGIC_BEGIN_INFO = "MAGIC-BEGIN-INFO";
|
|
readonly string MAGIC_BEGIN_EXT000 = "MAGIC-BEGIN-EXT000"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT001 = "MAGIC-BEGIN-EXT001"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT002 = "MAGIC-BEGIN-EXT002"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT003 = "MAGIC-BEGIN-EXT003"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT004 = "MAGIC-BEGIN-EXT004"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT005 = "MAGIC-BEGIN-EXT005"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT006 = "MAGIC-BEGIN-EXT006"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT007 = "MAGIC-BEGIN-EXT007"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT008 = "MAGIC-BEGIN-EXT008"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_EXT009 = "MAGIC-BEGIN-EXT009"; // reserved for future use
|
|
readonly string MAGIC_BEGIN_VOLUME = "PaRtImAgE-VoLuMe";
|
|
#endregion
|
|
|
|
#region Internal Structures
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
/// <summary>
|
|
/// Partimage disk image header, little-endian
|
|
/// </summary>
|
|
struct PartimageHeader
|
|
{
|
|
/// <summary>
|
|
/// Magic, <see cref="PartimageMagic"/>
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
|
|
public byte[] magic;
|
|
/// <summary>
|
|
/// Source filesystem
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
|
|
public byte[] version;
|
|
/// <summary>
|
|
/// Volume number
|
|
/// </summary>
|
|
public uint volumeNumber;
|
|
/// <summary>
|
|
/// Image identifier
|
|
/// </summary>
|
|
public ulong identificator;
|
|
/// <summary>
|
|
/// Empty space
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 404)]
|
|
public byte[] reserved;
|
|
}
|
|
|
|
struct portable_tm
|
|
{
|
|
public uint tm_sec;
|
|
public uint tm_min;
|
|
public uint tm_hour;
|
|
public uint tm_mday;
|
|
public uint tm_mon;
|
|
public uint tm_year;
|
|
public uint tm_wday;
|
|
public uint tm_yday;
|
|
public uint tm_isdst;
|
|
|
|
public uint tm_gmtoff;
|
|
public uint tm_zone;
|
|
};
|
|
|
|
enum pCompression : uint
|
|
{
|
|
None = 0,
|
|
Gzip = 1,
|
|
Bzip2 = 2,
|
|
Lzo = 3
|
|
}
|
|
|
|
enum pEncryption : uint
|
|
{
|
|
None = 0,
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
/// <summary>
|
|
/// Partimage CMainHeader
|
|
/// </summary>
|
|
struct PartimageMainHeader
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 512)]
|
|
public byte[] szFileSystem; // ext2fs, ntfs, reiserfs, ...
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_DESCRIPTION)]
|
|
public byte[] szPartDescription; // user description of the partition
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_DEVICENAMELEN)]
|
|
public byte[] szOriginalDevice; // original partition name
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4095)]
|
|
public byte[] szFirstImageFilepath; //MAXPATHLEN]; // for splitted image files
|
|
|
|
// system and hardware infos
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_UNAMEINFOLEN)]
|
|
public byte[] szUnameSysname;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_UNAMEINFOLEN)]
|
|
public byte[] szUnameNodename;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_UNAMEINFOLEN)]
|
|
public byte[] szUnameRelease;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_UNAMEINFOLEN)]
|
|
public byte[] szUnameVersion;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_UNAMEINFOLEN)]
|
|
public byte[] szUnameMachine;
|
|
|
|
public pCompression dwCompression; // COMPRESS_XXXXXX
|
|
public uint dwMainFlags;
|
|
public portable_tm dateCreate; // date of image creation
|
|
public ulong qwPartSize; // size of the partition in bytes
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_HOSTNAMESIZE)]
|
|
public byte[] szHostname;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
|
|
public byte[] szVersion; // version of the image file
|
|
|
|
// MBR backup
|
|
public uint dwMbrCount; // how many MBR are saved in the image file
|
|
public uint dwMbrSize; // size of a MBR record (allow to change the size in the next versions)
|
|
|
|
// future encryption support
|
|
public pEncryption dwEncryptAlgo; // algo used to encrypt data
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public byte[] cHashTestKey; // used to test the password without giving it
|
|
|
|
// reserved for future use (save DiskLabel, Extended partitions, ...)
|
|
public uint dwReservedFuture000;
|
|
public uint dwReservedFuture001;
|
|
public uint dwReservedFuture002;
|
|
public uint dwReservedFuture003;
|
|
public uint dwReservedFuture004;
|
|
public uint dwReservedFuture005;
|
|
public uint dwReservedFuture006;
|
|
public uint dwReservedFuture007;
|
|
public uint dwReservedFuture008;
|
|
public uint dwReservedFuture009;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6524)]
|
|
public byte[] cReserved; // Adjust to fit with total header size
|
|
|
|
public uint crc;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
struct CMbr // must be 1024
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MBR_SIZE_WHOLE)]
|
|
public byte[] cData;
|
|
public uint dwDataCRC;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_DEVICENAMELEN)]
|
|
public byte[] szDevice; // ex: "hda"
|
|
|
|
// disk identificators
|
|
ulong qwBlocksCount;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_DESC_MODEL)]
|
|
public byte[] szDescModel;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 884)]
|
|
public byte[] cReserved; // for future use
|
|
|
|
//public byte[] szDescGeometry[MAX_DESC_GEOMETRY];
|
|
//public byte[] szDescIdentify[MAX_DESC_IDENTIFY];
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
struct CCheck
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
byte[] cMagic; // must be 'C','H','K'
|
|
public uint dwCRC; // CRC of the CHECK_FREQUENCY blocks
|
|
public ulong qwPos; // number of the last block written
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
struct CLocalHeader // size must be 16384 (adjust the reserved data)
|
|
{
|
|
public ulong qwBlockSize;
|
|
public ulong qwUsedBlocks;
|
|
public ulong qwBlocksCount;
|
|
public ulong qwBitmapSize; // bytes in the bitmap
|
|
public ulong qwBadBlocksCount;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
|
|
public byte[] szLabel;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16280)]
|
|
public byte[] cReserved; // Adjust to fit with total header size
|
|
|
|
public uint crc;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
struct CMainTail // size must be 16384 (adjust the reserved data)
|
|
{
|
|
public ulong qwCRC;
|
|
public uint dwVolumeNumber;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16372)]
|
|
public byte[] cReserved; // Adjust to fit with total header size
|
|
}
|
|
#endregion
|
|
|
|
PartimageHeader CVolumeHeader;
|
|
PartimageMainHeader CMainHeader;
|
|
byte[] bitmap;
|
|
Stream imageStream;
|
|
long dataOff;
|
|
|
|
Dictionary<ulong, byte[]> sectorCache;
|
|
|
|
const uint MaxCacheSize = 16777216;
|
|
uint maxCachedSectors = MaxCacheSize / 512;
|
|
|
|
ExtentsULong extents;
|
|
Dictionary<ulong, ulong> extentsOff;
|
|
|
|
public Partimage()
|
|
{
|
|
Name = "Partimage disk image";
|
|
PluginUUID = new Guid("AAFDB99D-2B77-49EA-831C-C9BB58C68C95");
|
|
ImageInfo = new ImageInfo();
|
|
ImageInfo.readableSectorTags = new List<SectorTagType>();
|
|
ImageInfo.readableMediaTags = new List<MediaTagType>();
|
|
ImageInfo.imageHasPartitions = false;
|
|
ImageInfo.imageHasSessions = false;
|
|
ImageInfo.imageApplication = "Partimage";
|
|
ImageInfo.imageApplicationVersion = null;
|
|
ImageInfo.imageCreator = null;
|
|
ImageInfo.imageComments = null;
|
|
ImageInfo.mediaManufacturer = null;
|
|
ImageInfo.mediaModel = null;
|
|
ImageInfo.mediaSerialNumber = null;
|
|
ImageInfo.mediaBarcode = null;
|
|
ImageInfo.mediaPartNumber = null;
|
|
ImageInfo.mediaSequence = 0;
|
|
ImageInfo.lastMediaSequence = 0;
|
|
ImageInfo.driveManufacturer = null;
|
|
ImageInfo.driveModel = null;
|
|
ImageInfo.driveSerialNumber = null;
|
|
ImageInfo.driveFirmwareRevision = null;
|
|
}
|
|
|
|
public override bool IdentifyImage(Filter imageFilter)
|
|
{
|
|
Stream stream = imageFilter.GetDataForkStream();
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
|
|
if(stream.Length < 512)
|
|
return false;
|
|
|
|
byte[] pHdr_b = new byte[Marshal.SizeOf(CVolumeHeader)];
|
|
stream.Read(pHdr_b, 0, Marshal.SizeOf(CVolumeHeader));
|
|
CVolumeHeader = new PartimageHeader();
|
|
IntPtr headerPtr = Marshal.AllocHGlobal(Marshal.SizeOf(CVolumeHeader));
|
|
Marshal.Copy(pHdr_b, 0, headerPtr, Marshal.SizeOf(CVolumeHeader));
|
|
CVolumeHeader = (PartimageHeader)Marshal.PtrToStructure(headerPtr, typeof(PartimageHeader));
|
|
Marshal.FreeHGlobal(headerPtr);
|
|
|
|
return PartimageMagic.SequenceEqual(CVolumeHeader.magic);
|
|
}
|
|
|
|
public override bool OpenImage(Filter imageFilter)
|
|
{
|
|
Stream stream = imageFilter.GetDataForkStream();
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
|
|
if(stream.Length < 512)
|
|
return false;
|
|
|
|
byte[] hdr_b = new byte[Marshal.SizeOf(CVolumeHeader)];
|
|
stream.Read(hdr_b, 0, Marshal.SizeOf(CVolumeHeader));
|
|
CVolumeHeader = new PartimageHeader();
|
|
IntPtr headerPtr = Marshal.AllocHGlobal(Marshal.SizeOf(CVolumeHeader));
|
|
Marshal.Copy(hdr_b, 0, headerPtr, Marshal.SizeOf(CVolumeHeader));
|
|
CVolumeHeader = (PartimageHeader)Marshal.PtrToStructure(headerPtr, typeof(PartimageHeader));
|
|
Marshal.FreeHGlobal(headerPtr);
|
|
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CVolumeHeader.magic = {0}", StringHandlers.CToString(CVolumeHeader.magic));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CVolumeHeader.version = {0}", StringHandlers.CToString(CVolumeHeader.version));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CVolumeHeader.volumeNumber = {0}", CVolumeHeader.volumeNumber);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CVolumeHeader.identificator = {0:X16}", CVolumeHeader.identificator);
|
|
|
|
// TODO: Support multifile volumes
|
|
if(CVolumeHeader.volumeNumber > 0)
|
|
throw new FeatureSupportedButNotImplementedImageException("Support for multiple volumes not supported");
|
|
|
|
hdr_b = new byte[Marshal.SizeOf(CMainHeader)];
|
|
stream.Read(hdr_b, 0, Marshal.SizeOf(CMainHeader));
|
|
CMainHeader = new PartimageMainHeader();
|
|
headerPtr = Marshal.AllocHGlobal(Marshal.SizeOf(CMainHeader));
|
|
Marshal.Copy(hdr_b, 0, headerPtr, Marshal.SizeOf(CMainHeader));
|
|
CMainHeader = (PartimageMainHeader)Marshal.PtrToStructure(headerPtr, typeof(PartimageMainHeader));
|
|
Marshal.FreeHGlobal(headerPtr);
|
|
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szFileSystem = {0}", StringHandlers.CToString(CMainHeader.szFileSystem));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szPartDescription = {0}", StringHandlers.CToString(CMainHeader.szPartDescription));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szOriginalDevice = {0}", StringHandlers.CToString(CMainHeader.szOriginalDevice));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szFirstImageFilepath = {0}", StringHandlers.CToString(CMainHeader.szFirstImageFilepath));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szUnameSysname = {0}", StringHandlers.CToString(CMainHeader.szUnameSysname));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szUnameNodename = {0}", StringHandlers.CToString(CMainHeader.szUnameNodename));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szUnameRelease = {0}", StringHandlers.CToString(CMainHeader.szUnameRelease));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szUnameVersion = {0}", StringHandlers.CToString(CMainHeader.szUnameVersion));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szUnameMachine = {0}", StringHandlers.CToString(CMainHeader.szUnameMachine));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwCompression = {0} ({1})", CMainHeader.dwCompression, (uint)CMainHeader.dwCompression);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwMainFlags = {0}", CMainHeader.dwMainFlags);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_sec = {0}", CMainHeader.dateCreate.tm_sec);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_min = {0}", CMainHeader.dateCreate.tm_min);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_hour = {0}", CMainHeader.dateCreate.tm_hour);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_mday = {0}", CMainHeader.dateCreate.tm_mday);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_mon = {0}", CMainHeader.dateCreate.tm_mon);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_year = {0}", CMainHeader.dateCreate.tm_year);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_wday = {0}", CMainHeader.dateCreate.tm_wday);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_yday = {0}", CMainHeader.dateCreate.tm_yday);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_isdst = {0}", CMainHeader.dateCreate.tm_isdst);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_gmtoffsec = {0}", CMainHeader.dateCreate.tm_gmtoff);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate.tm_zone = {0}", CMainHeader.dateCreate.tm_zone);
|
|
|
|
DateTime dateCreate = new DateTime(1900 + (int)CMainHeader.dateCreate.tm_year, (int)CMainHeader.dateCreate.tm_mon + 1,
|
|
(int)CMainHeader.dateCreate.tm_mday, (int)CMainHeader.dateCreate.tm_hour,
|
|
(int)CMainHeader.dateCreate.tm_min, (int)CMainHeader.dateCreate.tm_sec);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dateCreate = {0}", dateCreate);
|
|
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.qwPartSize = {0}", CMainHeader.qwPartSize);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szHostname = {0}", StringHandlers.CToString(CMainHeader.szHostname));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.szVersion = {0}", StringHandlers.CToString(CMainHeader.szVersion));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwMbrCount = {0}", CMainHeader.dwMbrCount);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwMbrSize = {0}", CMainHeader.dwMbrSize);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwEncryptAlgo = {0} ({1})", CMainHeader.dwEncryptAlgo, (uint)CMainHeader.dwEncryptAlgo);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "ArrayIsNullOrEmpty(CMainHeader.cHashTestKey) = {0}", ArrayHelpers.ArrayIsNullOrEmpty(CMainHeader.cHashTestKey));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture000 = {0}", CMainHeader.dwReservedFuture000);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture001 = {0}", CMainHeader.dwReservedFuture001);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture002 = {0}", CMainHeader.dwReservedFuture002);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture003 = {0}", CMainHeader.dwReservedFuture003);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture004 = {0}", CMainHeader.dwReservedFuture004);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture005 = {0}", CMainHeader.dwReservedFuture005);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture006 = {0}", CMainHeader.dwReservedFuture006);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture007 = {0}", CMainHeader.dwReservedFuture007);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture008 = {0}", CMainHeader.dwReservedFuture008);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.dwReservedFuture009 = {0}", CMainHeader.dwReservedFuture009);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "ArrayIsNullOrEmpty(CMainHeader.cReserved) = {0}", ArrayHelpers.ArrayIsNullOrEmpty(CMainHeader.cReserved));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CMainHeader.crc = 0x{0:X8}", CMainHeader.crc);
|
|
|
|
// partimage 0.6.1 does not support them either
|
|
if(CMainHeader.dwEncryptAlgo != pEncryption.None)
|
|
throw new ImageNotSupportedException("Encrypted images are currently not supported.");
|
|
|
|
string magic;
|
|
|
|
// Skip MBRs
|
|
if(CMainHeader.dwMbrCount > 0)
|
|
{
|
|
hdr_b = new byte[MAGIC_BEGIN_MBRBACKUP.Length];
|
|
stream.Read(hdr_b, 0, MAGIC_BEGIN_MBRBACKUP.Length);
|
|
magic = StringHandlers.CToString(hdr_b);
|
|
if(!magic.Equals(MAGIC_BEGIN_MBRBACKUP))
|
|
throw new ImageNotSupportedException("Cannot find MBRs");
|
|
|
|
stream.Seek(CMainHeader.dwMbrSize * CMainHeader.dwMbrCount, SeekOrigin.Current);
|
|
}
|
|
|
|
// Skip extended headers and their CRC fields
|
|
stream.Seek((MAGIC_BEGIN_EXT000.Length + 4) * 10, SeekOrigin.Current);
|
|
|
|
hdr_b = new byte[MAGIC_BEGIN_LOCALHEADER.Length];
|
|
stream.Read(hdr_b, 0, MAGIC_BEGIN_LOCALHEADER.Length);
|
|
magic = StringHandlers.CToString(hdr_b);
|
|
if(!magic.Equals(MAGIC_BEGIN_LOCALHEADER))
|
|
throw new ImageNotSupportedException("Cannot find local header");
|
|
|
|
hdr_b = new byte[Marshal.SizeOf(typeof(CLocalHeader))];
|
|
stream.Read(hdr_b, 0, Marshal.SizeOf(typeof(CLocalHeader)));
|
|
headerPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(CLocalHeader)));
|
|
Marshal.Copy(hdr_b, 0, headerPtr, Marshal.SizeOf(typeof(CLocalHeader)));
|
|
CLocalHeader localHeader = (CLocalHeader)Marshal.PtrToStructure(headerPtr, typeof(CLocalHeader));
|
|
Marshal.FreeHGlobal(headerPtr);
|
|
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CLocalHeader.qwBlockSize = {0}", localHeader.qwBlockSize);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CLocalHeader.qwUsedBlocks = {0}", localHeader.qwUsedBlocks);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CLocalHeader.qwBlocksCount = {0}", localHeader.qwBlocksCount);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CLocalHeader.qwBitmapSize = {0}", localHeader.qwBitmapSize);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CLocalHeader.qwBadBlocksCount = {0}", localHeader.qwBadBlocksCount);
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CLocalHeader.szLabel = {0}", StringHandlers.CToString(localHeader.szLabel));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "ArrayIsNullOrEmpty(CLocalHeader.cReserved) = {0}", ArrayHelpers.ArrayIsNullOrEmpty(localHeader.cReserved));
|
|
DicConsole.DebugWriteLine("Partimage plugin", "CLocalHeader.crc = 0x{0:X8}", localHeader.crc);
|
|
|
|
hdr_b = new byte[MAGIC_BEGIN_BITMAP.Length];
|
|
stream.Read(hdr_b, 0, MAGIC_BEGIN_BITMAP.Length);
|
|
magic = StringHandlers.CToString(hdr_b);
|
|
if(!magic.Equals(MAGIC_BEGIN_BITMAP))
|
|
throw new ImageNotSupportedException("Cannot find bitmap");
|
|
|
|
bitmap = new byte[localHeader.qwBitmapSize];
|
|
stream.Read(bitmap, 0, (int)localHeader.qwBitmapSize);
|
|
|
|
hdr_b = new byte[MAGIC_BEGIN_INFO.Length];
|
|
stream.Read(hdr_b, 0, MAGIC_BEGIN_INFO.Length);
|
|
magic = StringHandlers.CToString(hdr_b);
|
|
if(!magic.Equals(MAGIC_BEGIN_INFO))
|
|
throw new ImageNotSupportedException("Cannot find info block");
|
|
|
|
// Skip info block and its checksum
|
|
stream.Seek(16384 + 4, SeekOrigin.Current);
|
|
|
|
hdr_b = new byte[MAGIC_BEGIN_DATABLOCKS.Length];
|
|
stream.Read(hdr_b, 0, MAGIC_BEGIN_DATABLOCKS.Length);
|
|
magic = StringHandlers.CToString(hdr_b);
|
|
if(!magic.Equals(MAGIC_BEGIN_DATABLOCKS))
|
|
throw new ImageNotSupportedException("Cannot find data blocks");
|
|
|
|
dataOff = stream.Position;
|
|
|
|
DicConsole.DebugWriteLine("Partimage plugin", "dataOff = {0}", dataOff);
|
|
|
|
// Seek to tail
|
|
stream.Seek(-(Marshal.SizeOf(typeof(CMainTail)) + MAGIC_BEGIN_TAIL.Length), SeekOrigin.End);
|
|
|
|
hdr_b = new byte[MAGIC_BEGIN_TAIL.Length];
|
|
stream.Read(hdr_b, 0, MAGIC_BEGIN_TAIL.Length);
|
|
magic = StringHandlers.CToString(hdr_b);
|
|
if(!magic.Equals(MAGIC_BEGIN_TAIL))
|
|
throw new ImageNotSupportedException("Cannot find tail. Multiple volumes are not supported or image is corrupt.");
|
|
|
|
DicConsole.DebugWriteLine("Partimage plugin", "Filling extents");
|
|
DateTime start = DateTime.Now;
|
|
extents = new ExtentsULong();
|
|
extentsOff = new Dictionary<ulong, ulong>();
|
|
bool current = (bitmap[0] & 1 << (int)(0 % 8)) != 0;
|
|
ulong blockOff = 0;
|
|
ulong extentStart = 0;
|
|
|
|
for(ulong i = 1; i <= localHeader.qwBlocksCount; i++)
|
|
{
|
|
bool next = (bitmap[i / 8] & 1 << (int)(i % 8)) != 0;
|
|
|
|
// Flux
|
|
if(next != current)
|
|
{
|
|
// Next is used
|
|
if(next)
|
|
{
|
|
extentStart = i;
|
|
extentsOff.Add(i, ++blockOff);
|
|
}
|
|
else
|
|
{
|
|
extents.Add(extentStart, i);
|
|
extentsOff.TryGetValue(extentStart, out ulong foo);
|
|
}
|
|
}
|
|
|
|
if(next && current)
|
|
blockOff++;
|
|
|
|
current = next;
|
|
}
|
|
DateTime end = DateTime.Now;
|
|
DicConsole.DebugWriteLine("Partimage plugin", "Took {0} seconds to fill extents", (end - start).TotalSeconds);
|
|
|
|
sectorCache = new Dictionary<ulong, byte[]>();
|
|
|
|
ImageInfo.imageCreationTime = dateCreate;
|
|
ImageInfo.imageLastModificationTime = imageFilter.GetLastWriteTime();
|
|
ImageInfo.imageName = Path.GetFileNameWithoutExtension(imageFilter.GetFilename());
|
|
ImageInfo.sectors = localHeader.qwBlocksCount + 1;
|
|
ImageInfo.sectorSize = (uint)localHeader.qwBlockSize;
|
|
ImageInfo.xmlMediaType = XmlMediaType.BlockMedia;
|
|
ImageInfo.mediaType = MediaType.GENERIC_HDD;
|
|
ImageInfo.imageVersion = StringHandlers.CToString(CMainHeader.szVersion);
|
|
ImageInfo.imageComments = StringHandlers.CToString(CMainHeader.szPartDescription);
|
|
ImageInfo.imageSize = (ulong)(stream.Length - (dataOff + Marshal.SizeOf(typeof(CMainTail)) + MAGIC_BEGIN_TAIL.Length));
|
|
imageStream = stream;
|
|
|
|
return true;
|
|
}
|
|
|
|
ulong BlockOffset(ulong sectorAddress)
|
|
{
|
|
extents.GetStart(sectorAddress, out ulong extentStart);
|
|
extentsOff.TryGetValue(extentStart, out ulong extentStartingOffset);
|
|
return extentStartingOffset + (sectorAddress - extentStart);
|
|
}
|
|
|
|
public override byte[] ReadSector(ulong sectorAddress)
|
|
{
|
|
if(sectorAddress > ImageInfo.sectors - 1)
|
|
throw new ArgumentOutOfRangeException(nameof(sectorAddress), string.Format("Sector address {0} not found", sectorAddress));
|
|
|
|
if((bitmap[sectorAddress / 8] & 1 << (int)(sectorAddress % 8)) == 0)
|
|
return new byte[ImageInfo.sectorSize];
|
|
|
|
byte[] sector;
|
|
|
|
if(sectorCache.TryGetValue(sectorAddress, out sector))
|
|
return sector;
|
|
|
|
ulong blockOff = BlockOffset(sectorAddress);
|
|
|
|
// Offset of requested sector is:
|
|
// Start of data +
|
|
long imageOff = dataOff +
|
|
// How many stored bytes to skip
|
|
(long)(blockOff * ImageInfo.sectorSize) +
|
|
// How many bytes of CRC blocks to skip
|
|
(long)(blockOff / (CHECK_FREQUENCY / ImageInfo.sectorSize)) * Marshal.SizeOf(typeof(CCheck));
|
|
|
|
sector = new byte[ImageInfo.sectorSize];
|
|
imageStream.Seek(imageOff, SeekOrigin.Begin);
|
|
imageStream.Read(sector, 0, (int)ImageInfo.sectorSize);
|
|
|
|
if(sectorCache.Count > maxCachedSectors)
|
|
{
|
|
System.Console.WriteLine("Cache cleared");
|
|
sectorCache.Clear();
|
|
}
|
|
|
|
sectorCache.Add(sectorAddress, sector);
|
|
|
|
return sector;
|
|
}
|
|
|
|
public override byte[] ReadSectors(ulong sectorAddress, uint length)
|
|
{
|
|
if(sectorAddress > ImageInfo.sectors - 1)
|
|
throw new ArgumentOutOfRangeException(nameof(sectorAddress), string.Format("Sector address {0} not found", sectorAddress));
|
|
|
|
if(sectorAddress + length > ImageInfo.sectors)
|
|
throw new ArgumentOutOfRangeException(nameof(length), "Requested more sectors than available");
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
|
|
bool allEmpty = true;
|
|
for(uint i = 0; i < length; i++)
|
|
{
|
|
if((bitmap[sectorAddress / 8] & 1 << (int)(sectorAddress % 8)) != 0)
|
|
{
|
|
allEmpty = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(allEmpty)
|
|
return new byte[ImageInfo.sectorSize * length];
|
|
|
|
for(uint i = 0; i < length; i++)
|
|
{
|
|
byte[] sector = ReadSector(sectorAddress + i);
|
|
ms.Write(sector, 0, sector.Length);
|
|
}
|
|
|
|
return ms.ToArray();
|
|
}
|
|
|
|
public override bool ImageHasPartitions()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override ulong GetImageSize()
|
|
{
|
|
return ImageInfo.imageSize;
|
|
}
|
|
|
|
public override ulong GetSectors()
|
|
{
|
|
return ImageInfo.sectors;
|
|
}
|
|
|
|
public override uint GetSectorSize()
|
|
{
|
|
return ImageInfo.sectorSize;
|
|
}
|
|
|
|
public override string GetImageFormat()
|
|
{
|
|
return "Partimage";
|
|
}
|
|
|
|
public override string GetImageVersion()
|
|
{
|
|
return ImageInfo.imageVersion;
|
|
}
|
|
|
|
public override string GetImageApplication()
|
|
{
|
|
return ImageInfo.imageApplication;
|
|
}
|
|
|
|
public override string GetImageApplicationVersion()
|
|
{
|
|
return ImageInfo.imageApplicationVersion;
|
|
}
|
|
|
|
public override string GetImageCreator()
|
|
{
|
|
return ImageInfo.imageCreator;
|
|
}
|
|
|
|
public override DateTime GetImageCreationTime()
|
|
{
|
|
return ImageInfo.imageCreationTime;
|
|
}
|
|
|
|
public override DateTime GetImageLastModificationTime()
|
|
{
|
|
return ImageInfo.imageLastModificationTime;
|
|
}
|
|
|
|
public override string GetImageName()
|
|
{
|
|
return ImageInfo.imageName;
|
|
}
|
|
|
|
public override string GetImageComments()
|
|
{
|
|
return ImageInfo.imageComments;
|
|
}
|
|
|
|
public override MediaType GetMediaType()
|
|
{
|
|
return ImageInfo.mediaType;
|
|
}
|
|
|
|
#region Unsupported features
|
|
|
|
public override byte[] ReadSectorTag(ulong sectorAddress, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsTag(ulong sectorAddress, uint length, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadDiskTag(MediaTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSector(ulong sectorAddress, uint track)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorTag(ulong sectorAddress, uint track, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectors(ulong sectorAddress, uint length, uint track)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsTag(ulong sectorAddress, uint length, uint track, SectorTagType tag)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorLong(ulong sectorAddress)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorLong(ulong sectorAddress, uint track)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsLong(ulong sectorAddress, uint length)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override byte[] ReadSectorsLong(ulong sectorAddress, uint length, uint track)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override string GetMediaManufacturer()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetMediaModel()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetMediaSerialNumber()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetMediaBarcode()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetMediaPartNumber()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override int GetMediaSequence()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public override int GetLastDiskSequence()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public override string GetDriveManufacturer()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetDriveModel()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetDriveSerialNumber()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override List<Partition> GetPartitions()
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override List<Track> GetTracks()
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override List<Track> GetSessionTracks(Session session)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override List<Track> GetSessionTracks(ushort session)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override List<Session> GetSessions()
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override bool? VerifySector(ulong sectorAddress)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override bool? VerifySector(ulong sectorAddress, uint track)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
public override bool? VerifySectors(ulong sectorAddress, uint length, out List<ulong> FailingLBAs, out List<ulong> UnknownLBAs)
|
|
{
|
|
FailingLBAs = new List<ulong>();
|
|
UnknownLBAs = new List<ulong>();
|
|
for(ulong i = 0; i < ImageInfo.sectors; i++)
|
|
UnknownLBAs.Add(i);
|
|
return null;
|
|
}
|
|
|
|
public override bool? VerifySectors(ulong sectorAddress, uint length, uint track, out List<ulong> FailingLBAs, out List<ulong> UnknownLBAs)
|
|
{
|
|
throw new FeatureUnsupportedImageException("Feature not supported by image format");
|
|
}
|
|
|
|
// TODO: All blocks contain a CRC32 that's incompatible with current implementation. Need to check for compatibility.
|
|
public override bool? VerifyMediaImage()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|