mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 11:14:25 +00:00
557 lines
22 KiB
C#
557 lines
22 KiB
C#
// /***************************************************************************
|
|
// Aaru Data Preservation Suite
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : AppleMap.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Partitioning scheme plugins.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Manages Apple Partition Map.
|
|
//
|
|
// --[ 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-2025 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using Aaru.CommonTypes;
|
|
using Aaru.CommonTypes.Attributes;
|
|
using Aaru.CommonTypes.Enums;
|
|
using Aaru.CommonTypes.Interfaces;
|
|
using Aaru.Helpers;
|
|
using Aaru.Logging;
|
|
using Marshal = Aaru.Helpers.Marshal;
|
|
|
|
namespace Aaru.Partitions;
|
|
|
|
// Information about structures learnt from Inside Macintosh
|
|
// Constants from image testing
|
|
/// <inheritdoc />
|
|
/// <summary>Implements decoding of the Apple Partition Map</summary>
|
|
[SuppressMessage("ReSharper", "UnusedMember.Local")]
|
|
public sealed partial class AppleMap : IPartition
|
|
{
|
|
/// <summary>"ER", driver descriptor magic</summary>
|
|
const ushort DDM_MAGIC = 0x4552;
|
|
/// <summary>"PM", new entry magic</summary>
|
|
const ushort APM_MAGIC = 0x504D;
|
|
/// <summary>"TS", old map magic</summary>
|
|
const ushort APM_MAGIC_OLD = 0x5453;
|
|
/// <summary>Old indicator for HFS partition, "TFS1"</summary>
|
|
const uint HFS_MAGIC_OLD = 0x54465331;
|
|
const string MODULE_NAME = "Apple Partition Map (APM) Plugin";
|
|
|
|
#region IPartition Members
|
|
|
|
/// <inheritdoc />
|
|
public string Name => Localization.AppleMap_Name;
|
|
|
|
/// <inheritdoc />
|
|
public Guid Id => new("36405F8D-4F1A-07F5-209C-223D735D6D22");
|
|
|
|
/// <inheritdoc />
|
|
public string Author => Authors.NATALIA_PORTILLO;
|
|
|
|
/// <inheritdoc />
|
|
public bool GetInformation(IMediaImage imagePlugin, out List<Partition> partitions, ulong sectorOffset)
|
|
{
|
|
uint sectorSize = imagePlugin.Info.SectorSize is 2352 or 2448 ? 2048 : imagePlugin.Info.SectorSize;
|
|
|
|
partitions = [];
|
|
|
|
if(sectorOffset + 2 >= imagePlugin.Info.Sectors) return false;
|
|
|
|
ErrorNumber errno = imagePlugin.ReadSector(sectorOffset, false, out byte[] ddmSector, out _);
|
|
|
|
if(errno != ErrorNumber.NoError) return false;
|
|
|
|
ushort maxDrivers = 61;
|
|
|
|
switch(sectorSize)
|
|
{
|
|
case 256:
|
|
{
|
|
var tmp = new byte[512];
|
|
Array.Copy(ddmSector, 0, tmp, 0, 256);
|
|
ddmSector = tmp;
|
|
maxDrivers = 29;
|
|
|
|
break;
|
|
}
|
|
case < 256:
|
|
return false;
|
|
}
|
|
|
|
AppleDriverDescriptorMap ddm = Marshal.ByteArrayToStructureBigEndian<AppleDriverDescriptorMap>(ddmSector);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbSig = 0x{0:X4}", ddm.sbSig);
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbBlockSize = {0}", ddm.sbBlockSize);
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbBlocks = {0}", ddm.sbBlocks);
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbDevType = {0}", ddm.sbDevType);
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbDevId = {0}", ddm.sbDevId);
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbData = 0x{0:X8}", ddm.sbData);
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbDrvrCount = {0}", ddm.sbDrvrCount);
|
|
|
|
uint sequence = 0;
|
|
|
|
if(ddm.sbSig == DDM_MAGIC)
|
|
{
|
|
if(ddm.sbDrvrCount < maxDrivers)
|
|
{
|
|
ddm.sbMap = new AppleDriverEntry[ddm.sbDrvrCount];
|
|
|
|
for(var i = 0; i < ddm.sbDrvrCount; i++)
|
|
{
|
|
var tmp = new byte[8];
|
|
Array.Copy(ddmSector, 18 + i * 8, tmp, 0, 8);
|
|
ddm.sbMap[i] = Marshal.ByteArrayToStructureBigEndian<AppleDriverEntry>(tmp);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbMap[{1}].ddBlock = {0}", ddm.sbMap[i].ddBlock, i);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbMap[{1}].ddSize = {0}", ddm.sbMap[i].ddSize, i);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "ddm.sbMap[{1}].ddType = {0}", ddm.sbMap[i].ddType, i);
|
|
|
|
if(ddm.sbMap[i].ddSize == 0) continue;
|
|
|
|
var part = new Partition
|
|
{
|
|
Size = (ulong)(ddm.sbMap[i].ddSize * 512),
|
|
Length = (ulong)(ddm.sbMap[i].ddSize * 512 / sectorSize),
|
|
Sequence = sequence,
|
|
Offset = ddm.sbMap[i].ddBlock * sectorSize,
|
|
Start = ddm.sbMap[i].ddBlock + sectorOffset,
|
|
Type = "Apple_Driver"
|
|
};
|
|
|
|
if(ddm.sbMap[i].ddSize * 512 % sectorSize > 0) part.Length++;
|
|
|
|
partitions.Add(part);
|
|
|
|
sequence++;
|
|
}
|
|
}
|
|
}
|
|
|
|
errno = imagePlugin.ReadSector(1 + sectorOffset, false, out byte[] partSector, out _);
|
|
|
|
if(errno != ErrorNumber.NoError) return false;
|
|
|
|
AppleOldDevicePartitionMap oldMap =
|
|
Marshal.ByteArrayToStructureBigEndian<AppleOldDevicePartitionMap>(partSector);
|
|
|
|
// This is the easy one, no sector size mixing
|
|
if(oldMap.pdSig == APM_MAGIC_OLD)
|
|
{
|
|
for(var i = 2; i < partSector.Length; i += 12)
|
|
{
|
|
var tmp = new byte[12];
|
|
Array.Copy(partSector, i, tmp, 0, 12);
|
|
|
|
AppleMapOldPartitionEntry oldEntry =
|
|
Marshal.ByteArrayToStructureBigEndian<AppleMapOldPartitionEntry>(tmp);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "old_map.sbMap[{1}].pdStart = {0}", oldEntry.pdStart, (i - 2) / 12);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "old_map.sbMap[{1}].pdSize = {0}", oldEntry.pdSize, (i - 2) / 12);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "old_map.sbMap[{1}].pdFSID = 0x{0:X8}", oldEntry.pdFSID, (i - 2) / 12);
|
|
|
|
if(oldEntry is { pdSize: 0, pdFSID: 0 })
|
|
{
|
|
if(oldEntry.pdStart == 0) break;
|
|
|
|
continue;
|
|
}
|
|
|
|
var part = new Partition
|
|
{
|
|
Size = oldEntry.pdStart * ddm.sbBlockSize,
|
|
Length = oldEntry.pdStart * ddm.sbBlockSize / sectorSize,
|
|
Sequence = sequence,
|
|
Offset = oldEntry.pdSize * ddm.sbBlockSize,
|
|
Start = oldEntry.pdSize * ddm.sbBlockSize / sectorSize,
|
|
Scheme = Name,
|
|
Type = oldEntry.pdFSID == HFS_MAGIC_OLD ? "Apple_HFS" : $"0x{oldEntry.pdFSID:X8}"
|
|
};
|
|
|
|
partitions.Add(part);
|
|
|
|
sequence++;
|
|
}
|
|
|
|
return partitions.Count > 0;
|
|
}
|
|
|
|
AppleMapPartitionEntry entry;
|
|
uint entrySize;
|
|
uint entryCount;
|
|
uint sectorsToRead;
|
|
uint skipDdm;
|
|
|
|
// If sector is bigger than 512
|
|
if(ddmSector.Length > 512)
|
|
{
|
|
var tmp = new byte[512];
|
|
Array.Copy(ddmSector, 512, tmp, 0, 512);
|
|
entry = Marshal.ByteArrayToStructureBigEndian<AppleMapPartitionEntry>(tmp);
|
|
|
|
// Check for a partition entry that's 512-byte aligned
|
|
if(entry.signature == APM_MAGIC)
|
|
{
|
|
AaruLogging.Debug(MODULE_NAME, Localization.Found_misaligned_entry);
|
|
entrySize = 512;
|
|
entryCount = entry.entries;
|
|
skipDdm = 512;
|
|
sectorsToRead = (entryCount + 1) * 512 / sectorSize + 1;
|
|
}
|
|
else
|
|
{
|
|
entry = Marshal.ByteArrayToStructureBigEndian<AppleMapPartitionEntry>(partSector);
|
|
|
|
if(entry.signature == APM_MAGIC)
|
|
{
|
|
AaruLogging.Debug(MODULE_NAME, Localization.Found_aligned_entry);
|
|
entrySize = sectorSize;
|
|
entryCount = entry.entries;
|
|
skipDdm = sectorSize;
|
|
sectorsToRead = entryCount + 2;
|
|
}
|
|
else
|
|
return partitions.Count > 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
entry = Marshal.ByteArrayToStructureBigEndian<AppleMapPartitionEntry>(partSector);
|
|
|
|
if(entry.signature == APM_MAGIC)
|
|
{
|
|
AaruLogging.Debug(MODULE_NAME, Localization.Found_aligned_entry);
|
|
entrySize = sectorSize;
|
|
entryCount = entry.entries;
|
|
skipDdm = sectorSize;
|
|
sectorsToRead = entryCount + 2;
|
|
}
|
|
else
|
|
return partitions.Count > 0;
|
|
}
|
|
|
|
errno = imagePlugin.ReadSectors(sectorOffset, false, sectorsToRead, out byte[] entries, out _);
|
|
|
|
if(errno != ErrorNumber.NoError) return false;
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "entry_size = {0}", entrySize);
|
|
AaruLogging.Debug(MODULE_NAME, "entry_count = {0}", entryCount);
|
|
AaruLogging.Debug(MODULE_NAME, "skip_ddm = {0}", skipDdm);
|
|
AaruLogging.Debug(MODULE_NAME, "sectors_to_read = {0}", sectorsToRead);
|
|
|
|
var copy = new byte[entries.Length - skipDdm];
|
|
Array.Copy(entries, skipDdm, copy, 0, copy.Length);
|
|
entries = copy;
|
|
|
|
for(var i = 0; i < entryCount; i++)
|
|
{
|
|
var tmp = new byte[entrySize];
|
|
Array.Copy(entries, i * entrySize, tmp, 0, entrySize);
|
|
entry = Marshal.ByteArrayToStructureBigEndian<AppleMapPartitionEntry>(tmp);
|
|
|
|
if(entry.signature != APM_MAGIC) continue;
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].signature = 0x{1:X4}", i, entry.signature);
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].reserved1 = 0x{1:X4}", i, entry.reserved1);
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].entries = {1}", i, entry.entries);
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].start = {1}", i, entry.start);
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].sectors = {1}", i, entry.sectors);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].name = \"{1}\"", i, StringHandlers.CToString(entry.name));
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].type = \"{1}\"", i, StringHandlers.CToString(entry.type));
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].first_data_block = {1}", i, entry.first_data_block);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].data_sectors = {1}", i, entry.data_sectors);
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].flags = {1}", i, (AppleMapFlags)entry.flags);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].first_boot_block = {1}", i, entry.first_boot_block);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].boot_size = {1}", i, entry.boot_size);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].load_address = 0x{1:X8}", i, entry.load_address);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].load_address2 = 0x{1:X8}", i, entry.load_address2);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].entry_point = 0x{1:X8}", i, entry.entry_point);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].entry_point2 = 0x{1:X8}", i, entry.entry_point2);
|
|
|
|
AaruLogging.Debug(MODULE_NAME, "dpme[{0}].checksum = 0x{1:X8}", i, entry.checksum);
|
|
|
|
AaruLogging.Debug(MODULE_NAME,
|
|
"dpme[{0}].processor = \"{1}\"",
|
|
i,
|
|
StringHandlers.CToString(entry.processor));
|
|
|
|
var flags = (AppleMapFlags)entry.flags;
|
|
|
|
// BeOS doesn't mark its partitions as valid
|
|
//if(flags.HasFlag(AppleMapFlags.Valid) &&
|
|
if(StringHandlers.CToString(entry.type) == "Apple_partition_map" || entry.sectors <= 0) continue;
|
|
|
|
var sb = new StringBuilder();
|
|
|
|
var partition = new Partition
|
|
{
|
|
Sequence = sequence,
|
|
Type = StringHandlers.CToString(entry.type),
|
|
Name = StringHandlers.CToString(entry.name),
|
|
Offset = entry.start * entrySize,
|
|
Size = entry.sectors * entrySize,
|
|
Start = entry.start * entrySize / sectorSize + sectorOffset,
|
|
Length = entry.sectors * entrySize / sectorSize,
|
|
Scheme = Name
|
|
};
|
|
|
|
sb.AppendLine(Localization.Partition_flags);
|
|
|
|
if(flags.HasFlag(AppleMapFlags.Valid)) sb.AppendLine(Localization.Partition_is_valid);
|
|
|
|
if(flags.HasFlag(AppleMapFlags.Allocated)) sb.AppendLine(Localization.Partition_entry_is_allocated);
|
|
|
|
if(flags.HasFlag(AppleMapFlags.InUse)) sb.AppendLine(Localization.Partition_is_in_use);
|
|
|
|
if(flags.HasFlag(AppleMapFlags.Bootable)) sb.AppendLine(Localization.Partition_is_bootable);
|
|
|
|
if(flags.HasFlag(AppleMapFlags.Readable)) sb.AppendLine(Localization.Partition_is_readable);
|
|
|
|
if(flags.HasFlag(AppleMapFlags.Writable)) sb.AppendLine(Localization.Partition_is_writable);
|
|
|
|
if(flags.HasFlag(AppleMapFlags.Bootable))
|
|
{
|
|
sb.AppendFormat(Localization.First_boot_sector_0, entry.first_boot_block * entrySize / sectorSize)
|
|
.AppendLine();
|
|
|
|
sb.AppendFormat(Localization.Boot_is_0_bytes, entry.boot_size).AppendLine();
|
|
sb.AppendFormat(Localization.Boot_load_address_0_X8, entry.load_address).AppendLine();
|
|
sb.AppendFormat(Localization.Boot_entry_point_0_X8, entry.entry_point).AppendLine();
|
|
sb.AppendFormat(Localization.Boot_code_checksum_0_X8, entry.checksum).AppendLine();
|
|
sb.AppendFormat(Localization.Processor_0, StringHandlers.CToString(entry.processor)).AppendLine();
|
|
|
|
if(flags.HasFlag(AppleMapFlags.PicCode))
|
|
sb.AppendLine(Localization.Partition_boot_code_is_position_independent);
|
|
}
|
|
|
|
partition.Description = sb.ToString();
|
|
|
|
if(partition.Start < imagePlugin.Info.Sectors && partition.End < imagePlugin.Info.Sectors)
|
|
{
|
|
partitions.Add(partition);
|
|
sequence++;
|
|
}
|
|
|
|
// Some CD and DVDs end with an Apple_Free that expands beyond the disc size...
|
|
else if(partition.Start < imagePlugin.Info.Sectors)
|
|
{
|
|
AaruLogging.Debug(MODULE_NAME,
|
|
Localization.Cutting_last_partition_end_0_to_media_size_1,
|
|
partition.End,
|
|
imagePlugin.Info.Sectors - 1);
|
|
|
|
partition.Length = imagePlugin.Info.Sectors - partition.Start;
|
|
partitions.Add(partition);
|
|
sequence++;
|
|
}
|
|
else
|
|
{
|
|
AaruLogging.Debug(MODULE_NAME,
|
|
Localization.Not_adding_partition_because_start_0_is_outside_media_size_1,
|
|
partition.Start,
|
|
imagePlugin.Info.Sectors - 1);
|
|
}
|
|
}
|
|
|
|
return partitions.Count > 0;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nested type: AppleDriverDescriptorMap
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
[SwapEndian]
|
|
partial struct AppleDriverDescriptorMap
|
|
{
|
|
/// <summary>Signature <see cref="DDM_MAGIC" /></summary>
|
|
public ushort sbSig;
|
|
/// <summary>Bytes per sector</summary>
|
|
public ushort sbBlockSize;
|
|
/// <summary>Sectors of the disk</summary>
|
|
public uint sbBlocks;
|
|
/// <summary>Device type</summary>
|
|
public ushort sbDevType;
|
|
/// <summary>Device ID</summary>
|
|
public ushort sbDevId;
|
|
/// <summary>Reserved</summary>
|
|
public uint sbData;
|
|
/// <summary>Number of entries of the driver descriptor</summary>
|
|
public ushort sbDrvrCount;
|
|
/// <summary>Entries of the driver descriptor</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 61)]
|
|
public AppleDriverEntry[] sbMap;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nested type: AppleDriverEntry
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
[SwapEndian]
|
|
partial struct AppleDriverEntry
|
|
{
|
|
/// <summary>First sector of the driver</summary>
|
|
public uint ddBlock;
|
|
/// <summary>Size in 512bytes sectors of the driver</summary>
|
|
public ushort ddSize;
|
|
/// <summary>Operating system (MacOS = 1)</summary>
|
|
public ushort ddType;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nested type: AppleMapFlags
|
|
|
|
[Flags]
|
|
enum AppleMapFlags : uint
|
|
{
|
|
/// <summary>Partition is valid</summary>
|
|
Valid = 0x01,
|
|
/// <summary>Partition is allocated</summary>
|
|
Allocated = 0x02,
|
|
/// <summary>Partition is in use</summary>
|
|
InUse = 0x04,
|
|
/// <summary>Partition is bootable</summary>
|
|
Bootable = 0x08,
|
|
/// <summary>Partition is readable</summary>
|
|
Readable = 0x10,
|
|
/// <summary>Partition is writable</summary>
|
|
Writable = 0x20,
|
|
/// <summary>Partition boot code is position independent</summary>
|
|
PicCode = 0x40,
|
|
/// <summary>OS specific flag</summary>
|
|
Specific1 = 0x80,
|
|
/// <summary>OS specific flag</summary>
|
|
Specific2 = 0x100,
|
|
/// <summary>Unknown, seen in the wild</summary>
|
|
Unknown = 0x200,
|
|
/// <summary>Unknown, seen in the wild</summary>
|
|
Unknown2 = 0x40000000,
|
|
/// <summary>Reserved, not seen in the wild</summary>
|
|
Reserved = 0xBFFFFC00
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nested type: AppleMapOldPartitionEntry
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
[SwapEndian]
|
|
partial struct AppleMapOldPartitionEntry
|
|
{
|
|
/// <summary>First sector of the partition</summary>
|
|
public uint pdStart;
|
|
/// <summary>Number of sectors of the partition</summary>
|
|
public uint pdSize;
|
|
/// <summary>Partition type</summary>
|
|
public uint pdFSID;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nested type: AppleMapPartitionEntry
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
[SwapEndian]
|
|
partial struct AppleMapPartitionEntry
|
|
{
|
|
/// <summary>Signature <see cref="APM_MAGIC" /></summary>
|
|
public ushort signature;
|
|
/// <summary>Reserved</summary>
|
|
public ushort reserved1;
|
|
/// <summary>Number of entries on the partition map, each one sector</summary>
|
|
public uint entries;
|
|
/// <summary>First sector of the partition</summary>
|
|
public uint start;
|
|
/// <summary>Number of sectos of the partition</summary>
|
|
public uint sectors;
|
|
/// <summary>Partition name, 32 bytes, null-padded</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
|
|
public byte[] name;
|
|
/// <summary>Partition type. 32 bytes, null-padded</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
|
|
public byte[] type;
|
|
/// <summary>First sector of the data area</summary>
|
|
public uint first_data_block;
|
|
/// <summary>Number of sectors of the data area</summary>
|
|
public uint data_sectors;
|
|
/// <summary>Partition flags</summary>
|
|
public uint flags;
|
|
/// <summary>First sector of the boot code</summary>
|
|
public uint first_boot_block;
|
|
/// <summary>Size in bytes of the boot code</summary>
|
|
public uint boot_size;
|
|
/// <summary>Load address of the boot code</summary>
|
|
public uint load_address;
|
|
/// <summary>Load address of the boot code</summary>
|
|
public uint load_address2;
|
|
/// <summary>Entry point of the boot code</summary>
|
|
public uint entry_point;
|
|
/// <summary>Entry point of the boot code</summary>
|
|
public uint entry_point2;
|
|
/// <summary>Boot code checksum</summary>
|
|
public uint checksum;
|
|
/// <summary>Processor type, 16 bytes, null-padded</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public byte[] processor;
|
|
/// <summary>Boot arguments</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
|
|
public uint[] boot_arguments;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nested type: AppleOldDevicePartitionMap
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
[SwapEndian]
|
|
partial struct AppleOldDevicePartitionMap
|
|
{
|
|
/// <summary>Signature <see cref="APM_MAGIC_OLD" /></summary>
|
|
public ushort pdSig;
|
|
/// <summary>Entries of the driver descriptor</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 42)]
|
|
public AppleMapOldPartitionEntry[] pdMap;
|
|
}
|
|
|
|
#endregion
|
|
} |