aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 19:24:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add more optimized marshallers.

Browse Source
This commit is contained in:
Natalia Portillo
2019-02-27 08:49:42 +00:00
parent bfe254279c
commit 45be793491
58 changed files with 593 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
DiscImageChef.Filesystems/AmigaDOS.cs
View File

@@ -39,6 +39,7 @@ using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using DiscImageChef.Console;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -69,14 +70,14 @@ namespace DiscImageChef.Filesystems
// size for floppies is the sector size, and for RDB is usually is the hard disk sector size,
// so this is not entirely wrong...
byte[] sector = imagePlugin.ReadSectors(0 + partition.Start, 2);
BootBlock bblk = BigEndianMarshal.ByteArrayToStructureBigEndian<BootBlock>(sector);
BootBlock bblk = Marshal.ByteArrayToStructureBigEndian<BootBlock>(sector);
// AROS boot floppies...
if(sector.Length >= 512 && sector[510] == 0x55 && sector[511] == 0xAA &&
(bblk.diskType & FFS_MASK) != FFS_MASK && (bblk.diskType & MUFS_MASK) != MUFS_MASK)
{
sector = imagePlugin.ReadSectors(1 + partition.Start, 2);
bblk = BigEndianMarshal.ByteArrayToStructureBigEndian<BootBlock>(sector);
bblk = Marshal.ByteArrayToStructureBigEndian<BootBlock>(sector);
}
// Not FFS or MuFS?
@@ -164,7 +165,7 @@ namespace DiscImageChef.Filesystems
byte[] bootBlockSectors = imagePlugin.ReadSectors(0 + partition.Start, 2);
BootBlock bootBlk = BigEndianMarshal.ByteArrayToStructureBigEndian<BootBlock>(bootBlockSectors);
BootBlock bootBlk = Marshal.ByteArrayToStructureBigEndian<BootBlock>(bootBlockSectors);
bootBlk.bootCode = new byte[bootBlockSectors.Length - 12];
Array.Copy(bootBlockSectors, 12, bootBlk.bootCode, 0, bootBlk.bootCode.Length);
bootBlockSectors[4] = bootBlockSectors[5] = bootBlockSectors[6] = bootBlockSectors[7] = 0;
@@ -339,7 +340,7 @@ namespace DiscImageChef.Filesystems
byte[] tmp = new byte[228];
Array.Copy(block, 0, tmp, 0, 24);
Array.Copy(block, block.Length - 200, tmp, 28, 200);
RootBlock root = BigEndianMarshal.ByteArrayToStructureBigEndian<RootBlock>(tmp);
RootBlock root = Marshal.ByteArrayToStructureBigEndian<RootBlock>(tmp);
root.hashTable = new uint[(block.Length - 224) / 4];
BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;
for(int i = 0; i < root.hashTable.Length; i++)

6
DiscImageChef.Filesystems/AppleHFS.cs
View File

@@ -36,6 +36,7 @@ using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -143,9 +144,8 @@ namespace DiscImageChef.Filesystems
else return;
}
HfsMasterDirectoryBlock mdb =
BigEndianMarshal.ByteArrayToStructureBigEndian<HfsMasterDirectoryBlock>(mdbSector);
HfsBootBlock bb = BigEndianMarshal.ByteArrayToStructureBigEndian<HfsBootBlock>(bbSector);
HfsMasterDirectoryBlock mdb = Marshal.ByteArrayToStructureBigEndian<HfsMasterDirectoryBlock>(mdbSector);
HfsBootBlock bb = Marshal.ByteArrayToStructureBigEndian<HfsBootBlock>(bbSector);
sb.AppendLine("Apple Hierarchical File System");
sb.AppendLine();

3
DiscImageChef.Filesystems/AppleHFSPlus.cs
View File

@@ -36,6 +36,7 @@ using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -159,7 +160,7 @@ namespace DiscImageChef.Filesystems
Array.Copy(vhSector, 0x400, tmp, 0, 0x400);
vhSector = tmp;
vh = BigEndianMarshal.ByteArrayToStructureBigEndian<HfsPlusVolumeHeader>(vhSector);
vh = Marshal.ByteArrayToStructureBigEndian<HfsPlusVolumeHeader>(vhSector);
if(vh.version == 4 || vh.version == 5)
{

2
DiscImageChef.Filesystems/BFS.cs
View File

@@ -133,7 +133,7 @@ namespace DiscImageChef.Filesystems
besb = (BeSuperBlock)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(BeSuperBlock));
handle.Free();
}
else besb = BigEndianMarshal.ByteArrayToStructureBigEndian<BeSuperBlock>(sbSector);
else besb = Helpers.Marshal.ByteArrayToStructureBigEndian<BeSuperBlock>(sbSector);
sb.AppendLine(littleEndian ? "Little-endian BeFS" : "Big-endian BeFS");

2
DiscImageChef.Filesystems/Cram.cs
View File

@@ -83,7 +83,7 @@ namespace DiscImageChef.Filesystems
Marshal.FreeHGlobal(crSbPtr);
break;
case CRAM_CIGAM:
crSb = BigEndianMarshal.ByteArrayToStructureBigEndian<CramSuperBlock>(sector);
crSb = Helpers.Marshal.ByteArrayToStructureBigEndian<CramSuperBlock>(sector);
littleEndian = false;
break;
}

8
DiscImageChef.Filesystems/EFS.cs
View File

@@ -72,7 +72,7 @@ namespace DiscImageChef.Filesystems
Array.Copy(sector, 0x200, sbpiece, 0, Marshal.SizeOf(efsSb));
efsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sbpiece);
efsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sbpiece);
DicConsole.DebugWriteLine("EFS plugin", "magic at 0x{0:X3} = 0x{1:X8} (expected 0x{2:X8} or 0x{3:X8})",
0x200, efsSb.sb_magic, EFS_MAGIC, EFS_MAGIC_NEW);
@@ -89,7 +89,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start + 1, sbSize);
if(sector.Length < Marshal.SizeOf(efsSb)) return false;
efsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sector);
efsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sector);
DicConsole.DebugWriteLine("EFS plugin", "magic at {0} = 0x{1:X8} (expected 0x{2:X8} or 0x{3:X8})", 1,
efsSb.sb_magic, EFS_MAGIC, EFS_MAGIC_NEW);
@@ -122,7 +122,7 @@ namespace DiscImageChef.Filesystems
Array.Copy(sector, 0x200, sbpiece, 0, Marshal.SizeOf(efsSb));
efsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sbpiece);
efsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sbpiece);
DicConsole.DebugWriteLine("EFS plugin", "magic at 0x{0:X3} = 0x{1:X8} (expected 0x{2:X8} or 0x{3:X8})",
0x200, efsSb.sb_magic, EFS_MAGIC, EFS_MAGIC_NEW);
@@ -135,7 +135,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start + 1, sbSize);
if(sector.Length < Marshal.SizeOf(efsSb)) return;
efsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sector);
efsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<EFS_Superblock>(sector);
DicConsole.DebugWriteLine("EFS plugin", "magic at {0} = 0x{1:X8} (expected 0x{2:X8} or 0x{3:X8})", 1,
efsSb.sb_magic, EFS_MAGIC, EFS_MAGIC_NEW);

144
DiscImageChef.Filesystems/FAT.cs
View File

@@ -42,6 +42,7 @@ using DiscImageChef.CommonTypes.Interfaces;
using DiscImageChef.Console;
using DiscImageChef.Helpers;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -138,10 +139,10 @@ namespace DiscImageChef.Filesystems
("d3e93f8b82ef250db216037d827a4896dc97d2be", "TracerST"), // OEM ID: "TracerST"
//("b741f85ef40288ccc8887de1f6e849009097e1c9", "Norton Utilities"), // OEM ID: "IBM PNCI", need to confirm
("c49b275537ac7237cac64d83f34d2024ae0ca96a",
"Windows NT (Spanish)"), // Need to check Windows >= 2000 (Spanish)
"Windows NT (Spanish)"), // Need to check Windows >= 2000 (Spanish)
//("a48b0e4b696317eed829e960d1aa576562a4f185", "TracerST"), // Unknown OEM ID, apparently Tracer, unconfirmed
("fe477972602ba76658ff7143859045b3c4036ca5",
"iomega"), // OEM ID: "SHIPDISK", contains timedate on boot code may not be unique
"iomega"), // OEM ID: "SHIPDISK", contains timedate on boot code may not be unique
("ef79a1f33e5237827eb812dda548f0e4e916d815", "GEOS"), // OEM ID: "GEOWORKS"
("8524587ee91494cc51cc2c9d07453e84be0cdc33", "Hero Soft v1.10"),
("681a0d9d662ba368e6acb0d0bf602e1f56411144", "Human68k 2.00")
@@ -182,8 +183,7 @@ namespace DiscImageChef.Filesystems
byte[] bpbSector = imagePlugin.ReadSectors(0 + partition.Start, sectorsPerBpb);
byte[] fatSector = imagePlugin.ReadSector(sectorsPerBpb + partition.Start);
HumanParameterBlock humanBpb =
BigEndianMarshal.ByteArrayToStructureBigEndian<HumanParameterBlock>(bpbSector);
HumanParameterBlock humanBpb = Marshal.ByteArrayToStructureBigEndian<HumanParameterBlock>(bpbSector);
ulong expectedClusters = humanBpb.bpc > 0 ? partition.Size / humanBpb.bpc : 0;
@@ -484,8 +484,7 @@ namespace DiscImageChef.Filesystems
byte[] bpbSector = imagePlugin.ReadSectors(0 + partition.Start, sectorsPerBpb);
HumanParameterBlock humanBpb =
BigEndianMarshal.ByteArrayToStructureBigEndian<HumanParameterBlock>(bpbSector);
HumanParameterBlock humanBpb = Marshal.ByteArrayToStructureBigEndian<HumanParameterBlock>(bpbSector);
ulong expectedClusters = humanBpb.bpc > 0 ? partition.Size / humanBpb.bpc : 0;
@@ -517,24 +516,43 @@ namespace DiscImageChef.Filesystems
if(imagePlugin.Info.SectorSize >= 256 && !useHumanBpb)
{
IntPtr bpbPtr = Marshal.AllocHGlobal(512);
Marshal.Copy(bpbSector, 0, bpbPtr, 512);
IntPtr bpbPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(512);
System.Runtime.InteropServices.Marshal.Copy(bpbSector, 0, bpbPtr, 512);
atariBpb = (AtariParameterBlock)Marshal.PtrToStructure(bpbPtr, typeof(AtariParameterBlock));
msxBpb = (MsxParameterBlock)Marshal.PtrToStructure(bpbPtr, typeof(MsxParameterBlock));
dos2Bpb = (BiosParameterBlock2)Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock2));
dos30Bpb = (BiosParameterBlock30)Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock30));
dos32Bpb = (BiosParameterBlock32)Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock32));
dos33Bpb = (BiosParameterBlock33)Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock33));
atariBpb =
(AtariParameterBlock)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(AtariParameterBlock));
msxBpb =
(MsxParameterBlock)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(MsxParameterBlock));
dos2Bpb =
(BiosParameterBlock2)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock2));
dos30Bpb =
(BiosParameterBlock30)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock30));
dos32Bpb =
(BiosParameterBlock32)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock32));
dos33Bpb =
(BiosParameterBlock33)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlock33));
shortEbpb =
(BiosParameterBlockShortEbpb)Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlockShortEbpb));
ebpb = (BiosParameterBlockEbpb)Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlockEbpb));
(BiosParameterBlockShortEbpb)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlockShortEbpb));
ebpb =
(BiosParameterBlockEbpb)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(BiosParameterBlockEbpb));
shortFat32Bpb =
(Fat32ParameterBlockShort)Marshal.PtrToStructure(bpbPtr, typeof(Fat32ParameterBlockShort));
fat32Bpb = (Fat32ParameterBlock)Marshal.PtrToStructure(bpbPtr, typeof(Fat32ParameterBlock));
apricotBpb = (ApricotLabel)Marshal.PtrToStructure(bpbPtr, typeof(ApricotLabel));
(Fat32ParameterBlockShort)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(Fat32ParameterBlockShort));
fat32Bpb =
(Fat32ParameterBlock)
System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(Fat32ParameterBlock));
apricotBpb =
(ApricotLabel)System.Runtime.InteropServices.Marshal.PtrToStructure(bpbPtr, typeof(ApricotLabel));
Marshal.FreeHGlobal(bpbPtr);
System.Runtime.InteropServices.Marshal.FreeHGlobal(bpbPtr);
int bitsInBpsAtari = CountBits.Count(atariBpb.bps);
int bitsInBpsMsx = CountBits.Count(msxBpb.bps);
@@ -1104,10 +1122,12 @@ namespace DiscImageChef.Filesystems
if(fat32Bpb.fsinfo_sector + partition.Start <= partition.End)
{
byte[] fsinfoSector = imagePlugin.ReadSector(fat32Bpb.fsinfo_sector + partition.Start);
IntPtr fsinfoPtr = Marshal.AllocHGlobal(512);
Marshal.Copy(fsinfoSector, 0, fsinfoPtr, 512);
FsInfoSector fsInfo = (FsInfoSector)Marshal.PtrToStructure(fsinfoPtr, typeof(FsInfoSector));
Marshal.FreeHGlobal(fsinfoPtr);
IntPtr fsinfoPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(512);
System.Runtime.InteropServices.Marshal.Copy(fsinfoSector, 0, fsinfoPtr, 512);
FsInfoSector fsInfo =
(FsInfoSector)
System.Runtime.InteropServices.Marshal.PtrToStructure(fsinfoPtr, typeof(FsInfoSector));
System.Runtime.InteropServices.Marshal.FreeHGlobal(fsinfoPtr);
if(fsInfo.signature1 == FSINFO_SIGNATURE1 && fsInfo.signature2 == FSINFO_SIGNATURE2 &&
fsInfo.signature3 == FSINFO_SIGNATURE3)
@@ -1540,10 +1560,12 @@ namespace DiscImageChef.Filesystems
// Not a volume label
if(rootDirectory[i + 0x0B] != 0x08 && rootDirectory[i + 0x0B] != 0x28) continue;
IntPtr entryPtr = Marshal.AllocHGlobal(32);
Marshal.Copy(rootDirectory, i, entryPtr, 32);
DirectoryEntry entry = (DirectoryEntry)Marshal.PtrToStructure(entryPtr, typeof(DirectoryEntry));
Marshal.FreeHGlobal(entryPtr);
IntPtr entryPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(32);
System.Runtime.InteropServices.Marshal.Copy(rootDirectory, i, entryPtr, 32);
DirectoryEntry entry =
(DirectoryEntry)
System.Runtime.InteropServices.Marshal.PtrToStructure(entryPtr, typeof(DirectoryEntry));
System.Runtime.InteropServices.Marshal.FreeHGlobal(entryPtr);
byte[] fullname = new byte[11];
Array.Copy(entry.filename, 0, fullname, 0, 8);
@@ -2137,15 +2159,18 @@ namespace DiscImageChef.Filesystems
/// <summary>Operating system.</summary>
public byte operatingSystem;
/// <summary>Software write protection.</summary>
[MarshalAs(UnmanagedType.U1)] public bool writeProtected;
[MarshalAs(UnmanagedType.U1)]
public bool writeProtected;
/// <summary>Copy protected.</summary>
[MarshalAs(UnmanagedType.U1)] public bool copyProtected;
[MarshalAs(UnmanagedType.U1)]
public bool copyProtected;
/// <summary>Boot type.</summary>
public byte bootType;
/// <summary>Partitions.</summary>
public byte partitionCount;
/// <summary>Is hard disk?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool winchester;
[MarshalAs(UnmanagedType.U1)]
public bool winchester;
/// <summary>Sector size.</summary>
public ushort sectorSize;
/// <summary>Sectors per track.</summary>
@@ -2198,15 +2223,18 @@ namespace DiscImageChef.Filesystems
/// <summary>Major BIOS version.</summary>
public byte biosMajorVersion;
/// <summary>Diagnostics enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool diagnosticsFlag;
[MarshalAs(UnmanagedType.U1)]
public bool diagnosticsFlag;
/// <summary>Printer device.</summary>
public byte prnDevice;
/// <summary>Bell volume.</summary>
public byte bellVolume;
/// <summary>Cache enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool enableCache;
[MarshalAs(UnmanagedType.U1)]
public bool enableCache;
/// <summary>Graphics enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool enableGraphics;
[MarshalAs(UnmanagedType.U1)]
public bool enableGraphics;
/// <summary>Length in sectors of DOS.</summary>
public byte dosLength;
/// <summary>Length in sectors of FONT file.</summary>
@@ -2222,7 +2250,8 @@ namespace DiscImageChef.Filesystems
/// <summary>Keyboard click volume.</summary>
public byte keyboardVolume;
/// <summary>Auto-repeat enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool autorepeat;
[MarshalAs(UnmanagedType.U1)]
public bool autorepeat;
/// <summary>Auto-repeat lead-in.</summary>
public byte autorepeatLeadIn;
/// <summary>Auto-repeat interval.</summary>
@@ -2237,7 +2266,8 @@ namespace DiscImageChef.Filesystems
/// <summary>Screen line width.</summary>
public byte lineWidth;
/// <summary>Screen disabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool imageOff;
[MarshalAs(UnmanagedType.U1)]
public bool imageOff;
/// <summary>Spare area for screen values expansion.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 13)]
public byte[] spareScreen;
@@ -2252,13 +2282,16 @@ namespace DiscImageChef.Filesystems
/// <summary>Stop bits.</summary>
public byte stopBits;
/// <summary>Parity enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool parityCheck;
[MarshalAs(UnmanagedType.U1)]
public bool parityCheck;
/// <summary>Parity type.</summary>
public byte parityType;
/// <summary>Xon/Xoff enabled on TX.</summary>
[MarshalAs(UnmanagedType.U1)] public bool txXonXoff;
[MarshalAs(UnmanagedType.U1)]
public bool txXonXoff;
/// <summary>Xon/Xoff enabled on RX.</summary>
[MarshalAs(UnmanagedType.U1)] public bool rxXonXoff;
[MarshalAs(UnmanagedType.U1)]
public bool rxXonXoff;
/// <summary>Xon character.</summary>
public byte xonCharacter;
/// <summary>Xoff character.</summary>
@@ -2266,30 +2299,39 @@ namespace DiscImageChef.Filesystems
/// <summary>Xon/Xoff buffer on RX.</summary>
public ushort rxXonXoffBuffer;
/// <summary>DTR/DSR enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool dtrDsr;
[MarshalAs(UnmanagedType.U1)]
public bool dtrDsr;
/// <summary>CTS/RTS enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool ctsRts;
[MarshalAs(UnmanagedType.U1)]
public bool ctsRts;
/// <summary>NULLs after CR.</summary>
public byte nullsAfterCr;
/// <summary>NULLs after 0xFF.</summary>
public byte nullsAfterFF;
/// <summary>Send LF after CR in serial port.</summary>
[MarshalAs(UnmanagedType.U1)] public bool lfAfterCRSerial;
[MarshalAs(UnmanagedType.U1)]
public bool lfAfterCRSerial;
/// <summary>BIOS error report in serial port.</summary>
[MarshalAs(UnmanagedType.U1)] public bool biosErrorReportSerial;
[MarshalAs(UnmanagedType.U1)]
public bool biosErrorReportSerial;
/// <summary>Spare area for serial port values expansion.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 13)]
public byte[] spareSerial;
/// <summary>Send LF after CR in parallel port.</summary>
[MarshalAs(UnmanagedType.U1)] public bool lfAfterCrParallel;
[MarshalAs(UnmanagedType.U1)]
public bool lfAfterCrParallel;
/// <summary>Select line supported?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool selectLine;
[MarshalAs(UnmanagedType.U1)]
public bool selectLine;
/// <summary>Paper empty supported?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool paperEmpty;
[MarshalAs(UnmanagedType.U1)]
public bool paperEmpty;
/// <summary>Fault line supported?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool faultLine;
[MarshalAs(UnmanagedType.U1)]
public bool faultLine;
/// <summary>BIOS error report in parallel port.</summary>
[MarshalAs(UnmanagedType.U1)] public bool biosErrorReportParallel;
[MarshalAs(UnmanagedType.U1)]
public bool biosErrorReportParallel;
/// <summary>Spare area for parallel port values expansion.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)]
public byte[] spareParallel;
@@ -2297,9 +2339,11 @@ namespace DiscImageChef.Filesystems
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 14)]
public byte[] spareWinchester;
/// <summary>Parking enabled?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool parkingEnabled;
[MarshalAs(UnmanagedType.U1)]
public bool parkingEnabled;
/// <summary>Format protection?.</summary>
[MarshalAs(UnmanagedType.U1)] public bool formatProtection;
[MarshalAs(UnmanagedType.U1)]
public bool formatProtection;
/// <summary>Spare area for RAM disk values expansion.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public byte[] spareRamDisk;

5
DiscImageChef.Filesystems/FATX.cs
View File

@@ -36,6 +36,7 @@ using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -55,7 +56,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSector(partition.Start);
FATX_Superblock fatxSb = BigEndianMarshal.ByteArrayToStructureBigEndian<FATX_Superblock>(sector);
FATX_Superblock fatxSb = Marshal.ByteArrayToStructureBigEndian<FATX_Superblock>(sector);
return fatxSb.magic == FATX_MAGIC;
}
@@ -69,7 +70,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSector(partition.Start);
FATX_Superblock fatxSb = BigEndianMarshal.ByteArrayToStructureBigEndian<FATX_Superblock>(sector);
FATX_Superblock fatxSb = Marshal.ByteArrayToStructureBigEndian<FATX_Superblock>(sector);
if(fatxSb.magic != FATX_MAGIC) return;

2
DiscImageChef.Filesystems/FFS.cs
View File

@@ -210,7 +210,7 @@ namespace DiscImageChef.Filesystems
UFSSuperBlock ufs_sb = (UFSSuperBlock)Marshal.PtrToStructure(sbPtr, typeof(UFSSuperBlock));
Marshal.FreeHGlobal(sbPtr);
UFSSuperBlock bs_sfu = BigEndianMarshal.ByteArrayToStructureBigEndian<UFSSuperBlock>(ufs_sb_sectors);
UFSSuperBlock bs_sfu = Helpers.Marshal.ByteArrayToStructureBigEndian<UFSSuperBlock>(ufs_sb_sectors);
if(bs_sfu.fs_magic == UFS_MAGIC && ufs_sb.fs_magic == UFS_CIGAM ||
bs_sfu.fs_magic == UFS_MAGIC_BW && ufs_sb.fs_magic == UFS_CIGAM_BW ||
bs_sfu.fs_magic == UFS2_MAGIC && ufs_sb.fs_magic == UFS2_CIGAM ||

7
DiscImageChef.Filesystems/Fossil.cs
View File

@@ -37,6 +37,7 @@ using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using DiscImageChef.Console;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -60,7 +61,7 @@ namespace DiscImageChef.Filesystems
if(partition.Start + hdrSector > imagePlugin.Info.Sectors) return false;
byte[] sector = imagePlugin.ReadSector(partition.Start + hdrSector);
FossilHeader hdr = BigEndianMarshal.ByteArrayToStructureBigEndian<FossilHeader>(sector);
FossilHeader hdr = Marshal.ByteArrayToStructureBigEndian<FossilHeader>(sector);
DicConsole.DebugWriteLine("Fossil plugin", "magic at 0x{0:X8} (expected 0x{1:X8})", hdr.magic,
FOSSIL_HDR_MAGIC);
@@ -79,7 +80,7 @@ namespace DiscImageChef.Filesystems
ulong hdrSector = HEADER_POS / imagePlugin.Info.SectorSize;
byte[] sector = imagePlugin.ReadSector(partition.Start + hdrSector);
FossilHeader hdr = BigEndianMarshal.ByteArrayToStructureBigEndian<FossilHeader>(sector);
FossilHeader hdr = Marshal.ByteArrayToStructureBigEndian<FossilHeader>(sector);
DicConsole.DebugWriteLine("Fossil plugin", "magic at 0x{0:X8} (expected 0x{1:X8})", hdr.magic,
FOSSIL_HDR_MAGIC);
@@ -104,7 +105,7 @@ namespace DiscImageChef.Filesystems
if(sbLocation <= partition.End)
{
sector = imagePlugin.ReadSector(sbLocation);
FossilSuperBlock fsb = BigEndianMarshal.ByteArrayToStructureBigEndian<FossilSuperBlock>(sector);
FossilSuperBlock fsb = Marshal.ByteArrayToStructureBigEndian<FossilSuperBlock>(sector);
DicConsole.DebugWriteLine("Fossil plugin", "magic 0x{0:X8} (expected 0x{1:X8})", fsb.magic,
FOSSIL_SB_MAGIC);

2
DiscImageChef.Filesystems/HAMMER.cs
View File

@@ -98,7 +98,7 @@ namespace DiscImageChef.Filesystems
typeof(HammerSuperBlock));
handle.Free();
}
else hammerSb = BigEndianMarshal.ByteArrayToStructureBigEndian<HammerSuperBlock>(sbSector);
else hammerSb = Helpers.Marshal.ByteArrayToStructureBigEndian<HammerSuperBlock>(sbSector);
sb.AppendLine("HAMMER filesystem");

4
DiscImageChef.Filesystems/HPOFS.cs
View File

@@ -94,9 +94,9 @@ namespace DiscImageChef.Filesystems
Marshal.FreeHGlobal(bpbPtr);
MediaInformationBlock mib =
BigEndianMarshal.ByteArrayToStructureBigEndian<MediaInformationBlock>(medInfoSector);
Helpers.Marshal.ByteArrayToStructureBigEndian<MediaInformationBlock>(medInfoSector);
VolumeInformationBlock vib =
BigEndianMarshal.ByteArrayToStructureBigEndian<VolumeInformationBlock>(volInfoSector);
Helpers.Marshal.ByteArrayToStructureBigEndian<VolumeInformationBlock>(volInfoSector);
DicConsole.DebugWriteLine("HPOFS Plugin", "bpb.oem_name = \"{0}\"",
StringHandlers.CToString(bpb.oem_name));

10
DiscImageChef.Filesystems/ISO9660/Info.cs
View File

@@ -179,7 +179,7 @@ namespace DiscImageChef.Filesystems.ISO9660
}
else if(cdi)
fsvd =
BigEndianMarshal.ByteArrayToStructureBigEndian<FileStructureVolumeDescriptor>(vdSector);
Helpers.Marshal.ByteArrayToStructureBigEndian<FileStructureVolumeDescriptor>(vdSector);
else
{
IntPtr ptr = Marshal.AllocHGlobal(2048);
@@ -295,7 +295,7 @@ namespace DiscImageChef.Filesystems.ISO9660
if(Marshal.SizeOf(typeof(CdromXa)) + saOff <= saLen)
{
CdromXa xa = BigEndianMarshal.ByteArrayToStructureBigEndian<CdromXa>(sa);
CdromXa xa = Helpers.Marshal.ByteArrayToStructureBigEndian<CdromXa>(sa);
if(xa.signature == XA_MAGIC)
{
xaExtensions = true;
@@ -360,8 +360,8 @@ namespace DiscImageChef.Filesystems.ISO9660
case SUSP_CONTINUATION when saOff + sa[saOff + 2] <= saLen:
byte[] ce = new byte[sa[saOff + 2]];
Array.Copy(sa, saOff, ce, 0, ce.Length);
ContinuationArea ca = BigEndianMarshal
.ByteArrayToStructureBigEndian<ContinuationArea>(ce);
ContinuationArea ca =
Helpers.Marshal.ByteArrayToStructureBigEndian<ContinuationArea>(ce);
contareas.Add(ca);
break;
case SUSP_REFERENCE when saOff + sa[saOff + 2] <= saLen:
@@ -458,7 +458,7 @@ namespace DiscImageChef.Filesystems.ISO9660
counter = 1;
foreach(byte[] erb in refareas)
{
ReferenceArea er = BigEndianMarshal.ByteArrayToStructureBigEndian<ReferenceArea>(erb);
ReferenceArea er = Helpers.Marshal.ByteArrayToStructureBigEndian<ReferenceArea>(erb);
string extId =
Encoding.GetString(erb, Marshal.SizeOf(er), er.id_len);
string extDes =

5
DiscImageChef.Filesystems/LIF.cs
View File

@@ -37,6 +37,7 @@ using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using DiscImageChef.Console;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -56,7 +57,7 @@ namespace DiscImageChef.Filesystems
if(imagePlugin.Info.SectorSize < 256) return false;
byte[] sector = imagePlugin.ReadSector(partition.Start);
LifSystemBlock lifSb = BigEndianMarshal.ByteArrayToStructureBigEndian<LifSystemBlock>(sector);
LifSystemBlock lifSb = Marshal.ByteArrayToStructureBigEndian<LifSystemBlock>(sector);
DicConsole.DebugWriteLine("LIF plugin", "magic 0x{0:X8} (expected 0x{1:X8})", lifSb.magic, LIF_MAGIC);
return lifSb.magic == LIF_MAGIC;
@@ -71,7 +72,7 @@ namespace DiscImageChef.Filesystems
if(imagePlugin.Info.SectorSize < 256) return;
byte[] sector = imagePlugin.ReadSector(partition.Start);
LifSystemBlock lifSb = BigEndianMarshal.ByteArrayToStructureBigEndian<LifSystemBlock>(sector);
LifSystemBlock lifSb = Marshal.ByteArrayToStructureBigEndian<LifSystemBlock>(sector);
if(lifSb.magic != LIF_MAGIC) return;

2
DiscImageChef.Filesystems/Locus.cs
View File

@@ -137,7 +137,7 @@ namespace DiscImageChef.Filesystems
// Numerical arrays are not important for information so no need to swap them
if(locusSb.s_magic == LOCUS_CIGAM || locusSb.s_magic == LOCUS_CIGAM_OLD)
{
locusSb = BigEndianMarshal.ByteArrayToStructureBigEndian<Locus_Superblock>(sector);
locusSb = Helpers.Marshal.ByteArrayToStructureBigEndian<Locus_Superblock>(sector);
locusSb.s_flags = (LocusFlags)Swapping.Swap((ushort)locusSb.s_flags);
}

4
DiscImageChef.Filesystems/MinixFS.cs
View File

@@ -237,7 +237,7 @@ namespace DiscImageChef.Filesystems
typeof(Minix3SuperBlock));
handle.Free();
}
else mnxSb = BigEndianMarshal.ByteArrayToStructureBigEndian<Minix3SuperBlock>(minixSbSector);
else mnxSb = Helpers.Marshal.ByteArrayToStructureBigEndian<Minix3SuperBlock>(minixSbSector);
if(magic != MINIX3_MAGIC && magic != MINIX3_CIGAM) mnxSb.s_blocksize = 1024;
@@ -274,7 +274,7 @@ namespace DiscImageChef.Filesystems
typeof(MinixSuperBlock));
handle.Free();
}
else mnxSb = BigEndianMarshal.ByteArrayToStructureBigEndian<MinixSuperBlock>(minixSbSector);
else mnxSb = Helpers.Marshal.ByteArrayToStructureBigEndian<MinixSuperBlock>(minixSbSector);
sb.AppendLine(minixVersion);
sb.AppendFormat("{0} chars in filename", filenamesize).AppendLine();

3
DiscImageChef.Filesystems/Opera.cs
View File

@@ -36,6 +36,7 @@ using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -74,7 +75,7 @@ namespace DiscImageChef.Filesystems
byte[] sbSector = imagePlugin.ReadSector(0 + partition.Start);
OperaSuperBlock sb = BigEndianMarshal.ByteArrayToStructureBigEndian<OperaSuperBlock>(sbSector);
OperaSuperBlock sb = Marshal.ByteArrayToStructureBigEndian<OperaSuperBlock>(sbSector);
sb.sync_bytes = new byte[5];
if(sb.record_type != 1 || sb.record_version != 1) return;

3
DiscImageChef.Filesystems/PFS.cs
View File

@@ -36,6 +36,7 @@ using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -87,7 +88,7 @@ namespace DiscImageChef.Filesystems
{
Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
byte[] rootBlockSector = imagePlugin.ReadSector(2 + partition.Start);
RootBlock rootBlock = BigEndianMarshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector);
RootBlock rootBlock = Marshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector);
StringBuilder sbInformation = new StringBuilder();
XmlFsType = new FileSystemType();

10
DiscImageChef.Filesystems/RBF.cs
View File

@@ -72,8 +72,8 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start + location, sbSize);
if(sector.Length < Marshal.SizeOf(rbfSb)) return false;
rbfSb = BigEndianMarshal.ByteArrayToStructureBigEndian<RBF_IdSector>(sector);
RBF_NewIdSector rbf9000Sb = BigEndianMarshal.ByteArrayToStructureBigEndian<RBF_NewIdSector>(sector);
rbfSb = Helpers.Marshal.ByteArrayToStructureBigEndian<RBF_IdSector>(sector);
RBF_NewIdSector rbf9000Sb = Helpers.Marshal.ByteArrayToStructureBigEndian<RBF_NewIdSector>(sector);
DicConsole.DebugWriteLine("RBF plugin",
"magic at {0} = 0x{1:X8} or 0x{2:X8} (expected 0x{3:X8} or 0x{4:X8})",
@@ -105,8 +105,8 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start + location, sbSize);
if(sector.Length < Marshal.SizeOf(rbfSb)) return;
rbfSb = BigEndianMarshal.ByteArrayToStructureBigEndian<RBF_IdSector>(sector);
rbf9000Sb = BigEndianMarshal.ByteArrayToStructureBigEndian<RBF_NewIdSector>(sector);
rbfSb = Helpers.Marshal.ByteArrayToStructureBigEndian<RBF_IdSector>(sector);
rbf9000Sb = Helpers.Marshal.ByteArrayToStructureBigEndian<RBF_NewIdSector>(sector);
DicConsole.DebugWriteLine("RBF plugin",
"magic at {0} = 0x{1:X8} or 0x{2:X8} (expected 0x{3:X8} or 0x{4:X8})",
@@ -118,7 +118,7 @@ namespace DiscImageChef.Filesystems
if(rbfSb.dd_sync != RBF_SYNC && rbf9000Sb.rid_sync != RBF_SYNC && rbf9000Sb.rid_sync != RBF_CNYS) return;
if(rbf9000Sb.rid_sync == RBF_CNYS)
rbf9000Sb = (RBF_NewIdSector)BigEndianMarshal.SwapStructureMembersEndian(rbf9000Sb);
rbf9000Sb = (RBF_NewIdSector)Helpers.Marshal.SwapStructureMembersEndian(rbf9000Sb);
StringBuilder sb = new StringBuilder();

3
DiscImageChef.Filesystems/SFS.cs
View File

@@ -36,6 +36,7 @@ using System.Text;
using DiscImageChef.CommonTypes;
using DiscImageChef.CommonTypes.Interfaces;
using Schemas;
using Marshal = DiscImageChef.Helpers.Marshal;
namespace DiscImageChef.Filesystems
{
@@ -70,7 +71,7 @@ namespace DiscImageChef.Filesystems
{
Encoding = encoding ?? Encoding.GetEncoding("iso-8859-1");
byte[] rootBlockSector = imagePlugin.ReadSector(partition.Start);
RootBlock rootBlock = BigEndianMarshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector);
RootBlock rootBlock = Marshal.ByteArrayToStructureBigEndian<RootBlock>(rootBlockSector);
StringBuilder sbInformation = new StringBuilder();

2
DiscImageChef.Filesystems/Squash.cs
View File

@@ -83,7 +83,7 @@ namespace DiscImageChef.Filesystems
Marshal.FreeHGlobal(sqSbPtr);
break;
case SQUASH_CIGAM:
sqSb = BigEndianMarshal.ByteArrayToStructureBigEndian<SquashSuperBlock>(sector);
sqSb = Helpers.Marshal.ByteArrayToStructureBigEndian<SquashSuperBlock>(sector);
littleEndian = false;
break;
}

4
DiscImageChef.Filesystems/UNICOS.cs
View File

@@ -74,7 +74,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start, sbSize);
if(sector.Length < Marshal.SizeOf(unicosSb)) return false;
unicosSb = BigEndianMarshal.ByteArrayToStructureBigEndian<UNICOS_Superblock>(sector);
unicosSb = Helpers.Marshal.ByteArrayToStructureBigEndian<UNICOS_Superblock>(sector);
DicConsole.DebugWriteLine("UNICOS plugin", "magic = 0x{0:X16} (expected 0x{1:X16})", unicosSb.s_magic,
UNICOS_MAGIC);
@@ -97,7 +97,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start, sbSize);
if(sector.Length < Marshal.SizeOf(unicosSb)) return;
unicosSb = BigEndianMarshal.ByteArrayToStructureBigEndian<UNICOS_Superblock>(sector);
unicosSb = Helpers.Marshal.ByteArrayToStructureBigEndian<UNICOS_Superblock>(sector);
if(unicosSb.s_magic != UNICOS_MAGIC) return;

8
DiscImageChef.Filesystems/XFS.cs
View File

@@ -72,7 +72,7 @@ namespace DiscImageChef.Filesystems
{
Array.Copy(sector, location, sbpiece, 0, Marshal.SizeOf(xfsSb));
xfsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sbpiece);
xfsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sbpiece);
DicConsole.DebugWriteLine("XFS plugin", "magic at 0x{0:X3} = 0x{1:X8} (expected 0x{2:X8})",
location, xfsSb.magicnum, XFS_MAGIC);
@@ -92,7 +92,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start + location, sbSize);
if(sector.Length < Marshal.SizeOf(xfsSb)) return false;
xfsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sector);
xfsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sector);
DicConsole.DebugWriteLine("XFS plugin", "magic at {0} = 0x{1:X8} (expected 0x{2:X8})", location,
xfsSb.magicnum, XFS_MAGIC);
@@ -127,7 +127,7 @@ namespace DiscImageChef.Filesystems
{
Array.Copy(sector, location, sbpiece, 0, Marshal.SizeOf(xfsSb));
xfsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sbpiece);
xfsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sbpiece);
DicConsole.DebugWriteLine("XFS plugin", "magic at 0x{0:X3} = 0x{1:X8} (expected 0x{2:X8})",
location, xfsSb.magicnum, XFS_MAGIC);
@@ -145,7 +145,7 @@ namespace DiscImageChef.Filesystems
byte[] sector = imagePlugin.ReadSectors(partition.Start + location, sbSize);
if(sector.Length < Marshal.SizeOf(xfsSb)) return;
xfsSb = BigEndianMarshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sector);
xfsSb = Helpers.Marshal.ByteArrayToStructureBigEndian<XFS_Superblock>(sector);
DicConsole.DebugWriteLine("XFS plugin", "magic at {0} = 0x{1:X8} (expected 0x{2:X8})", location,
xfsSb.magicnum, XFS_MAGIC);

4
DiscImageChef.Filesystems/dump.cs
View File

@@ -186,14 +186,14 @@ namespace DiscImageChef.Filesystems
newHdr.c_magic == NFS_CIGAM || newHdr.c_magic == UFS2_MAGIC || newHdr.c_magic == UFS2_CIGAM)
{
if(newHdr.c_magic == OFS_CIGAM || newHdr.c_magic == NFS_CIGAM || newHdr.c_magic == UFS2_CIGAM)
newHdr = BigEndianMarshal.ByteArrayToStructureBigEndian<s_spcl>(sector);
newHdr = Helpers.Marshal.ByteArrayToStructureBigEndian<s_spcl>(sector);
}
else if(aixHdr.c_magic == XIX_MAGIC || aixHdr.c_magic == XIX_CIGAM)
{
useAix = true;
if(aixHdr.c_magic == XIX_CIGAM)
aixHdr = BigEndianMarshal.ByteArrayToStructureBigEndian<spcl_aix>(sector);
aixHdr = Helpers.Marshal.ByteArrayToStructureBigEndian<spcl_aix>(sector);
}
else if(oldHdr.c_magic == OFS_MAGIC)
{