aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2025-12-16 11:14:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
fd04d4fe2a72eb98f33967211fe75ce44c46c35b
Aaru/Aaru.Filesystems/ISO9660/Info.cs

1030 lines
44 KiB
C#
Raw Blame History

// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename : Info.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : ISO9660 filesystem plugin.
//
// --[ 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
// In the loving memory of Facunda "Tata" Suárez Domínguez, R.I.P. 2019/07/24
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Text;
using Aaru.Checksums;
using Aaru.CommonTypes.AaruMetadata;
using Aaru.CommonTypes.Enums;
using Aaru.CommonTypes.Interfaces;
using Aaru.Decoders.Sega;
using Aaru.Helpers;
using Aaru.Logging;
using Partition = Aaru.CommonTypes.Partition;
namespace Aaru.Filesystems;
public sealed partial class ISO9660
{
#region IReadOnlyFilesystem Members
/// <inheritdoc />
public bool Identify(IMediaImage imagePlugin, Partition partition)
{
// ISO9660 is designed for 2048 bytes/sector devices
if(imagePlugin.Info.SectorSize < 2048) return false;
// ISO9660 Primary Volume Descriptor starts at sector 16, so that's minimal size.
if(partition.End <= 16 + partition.Start) return false;
// Read to Volume Descriptor
ErrorNumber errno = imagePlugin.ReadSector(16 + partition.Start, false, out byte[] vdSector, out _);
if(errno != ErrorNumber.NoError) return false;
var xaOff = 0;
if(vdSector.Length == 2336) xaOff = 8;
byte vdType = vdSector[0 + xaOff];
var vdMagic = new byte[5];
var hsMagic = new byte[5];
// This indicates the end of a volume descriptor. HighSierra here would have 16 so no problem
if(vdType == 255) return false;
Array.Copy(vdSector, 0x001 + xaOff, vdMagic, 0, 5);
Array.Copy(vdSector, 0x009 + xaOff, hsMagic, 0, 5);
AaruLogging.Debug(MODULE_NAME, "VDMagic = {0}", Encoding.ASCII.GetString(vdMagic));
AaruLogging.Debug(MODULE_NAME, "HSMagic = {0}", Encoding.ASCII.GetString(hsMagic));
return Encoding.ASCII.GetString(vdMagic) == ISO_MAGIC ||
Encoding.ASCII.GetString(hsMagic) == HIGH_SIERRA_MAGIC ||
Encoding.ASCII.GetString(vdMagic) == CDI_MAGIC;
}
/// <inheritdoc />
public void GetInformation(IMediaImage imagePlugin, Partition partition, Encoding encoding, out string information,
out FileSystem metadata)
{
encoding ??= Encoding.ASCII;
information = "";
metadata = new FileSystem();
var isoMetadata = new StringBuilder();
var vdMagic = new byte[5]; // Volume Descriptor magic "CD001"
var hsMagic = new byte[5]; // Volume Descriptor magic "CDROM"
var bootSpec = "";
PrimaryVolumeDescriptor? pvd = null;
PrimaryVolumeDescriptor? jolietvd = null;
BootRecord? bvd = null;
HighSierraPrimaryVolumeDescriptor? hsvd = null;
FileStructureVolumeDescriptor? fsvd = null;
ElToritoBootRecord? torito = null;
// ISO9660 is designed for 2048 bytes/sector devices
if(imagePlugin.Info.SectorSize < 2048) return;
// ISO9660 Primary Volume Descriptor starts at sector 16, so that's minimal size.
if(partition.End < 16) return;
ulong counter = 0;
ErrorNumber errno = imagePlugin.ReadSector(16 + partition.Start, false, out byte[] vdSector, out _);
if(errno != ErrorNumber.NoError) return;
int xaOff = vdSector.Length == 2336 ? 8 : 0;
Array.Copy(vdSector, 0x009 + xaOff, hsMagic, 0, 5);
bool highSierraInfo = encoding.GetString(hsMagic) == HIGH_SIERRA_MAGIC;
var hsOff = 0;
if(highSierraInfo) hsOff = 8;
var cdiInfo = false;
var evd = false;
var vpd = false;
while(true)
{
AaruLogging.Debug(MODULE_NAME, Localization.Processing_VD_loop_no_0, counter);
// Seek to Volume Descriptor
AaruLogging.Debug(MODULE_NAME, Localization.Reading_sector_0, 16 + counter + partition.Start);
errno = imagePlugin.ReadSector(16 + counter + partition.Start, false, out byte[] vdSectorTmp, out _);
if(errno != ErrorNumber.NoError) return;
vdSector = new byte[vdSectorTmp.Length - xaOff];
Array.Copy(vdSectorTmp, xaOff, vdSector, 0, vdSector.Length);
byte vdType = vdSector[0 + hsOff]; // Volume Descriptor Type, should be 1 or 2.
AaruLogging.Debug(MODULE_NAME, "VDType = {0}", vdType);
if(vdType == 255) // Supposedly we are in the PVD.
{
if(counter == 0) return;
break;
}
Array.Copy(vdSector, 0x001, vdMagic, 0, 5);
Array.Copy(vdSector, 0x009, hsMagic, 0, 5);
if(encoding.GetString(vdMagic) != ISO_MAGIC &&
encoding.GetString(hsMagic) != HIGH_SIERRA_MAGIC &&
encoding.GetString(vdMagic) != CDI_MAGIC) // Recognized, it is an ISO9660, now check for rest of data.
{
if(counter == 0) return;
break;
}
cdiInfo |= encoding.GetString(vdMagic) == CDI_MAGIC;
switch(vdType)
{
case 0:
{
bvd = Marshal.ByteArrayToStructureLittleEndian<BootRecord>(vdSector, hsOff, 2048 - hsOff);
bootSpec = Localization.Unknown_specification;
if(encoding.GetString(bvd.Value.system_id)[..23] == "EL TORITO SPECIFICATION")
{
bootSpec = "[green]El Torito[/]";
torito =
Marshal.ByteArrayToStructureLittleEndian<ElToritoBootRecord>(vdSector, hsOff, 2048 - hsOff);
}
break;
}
case 1:
{
if(highSierraInfo)
hsvd = Marshal.ByteArrayToStructureLittleEndian<HighSierraPrimaryVolumeDescriptor>(vdSector);
else if(cdiInfo)
fsvd = Marshal.ByteArrayToStructureBigEndian<FileStructureVolumeDescriptor>(vdSector);
else
pvd = Marshal.ByteArrayToStructureLittleEndian<PrimaryVolumeDescriptor>(vdSector);
break;
}
case 2:
{
PrimaryVolumeDescriptor svd =
Marshal.ByteArrayToStructureLittleEndian<PrimaryVolumeDescriptor>(vdSector);
// Check if this is Joliet
if(svd.version == 1)
{
if(svd.escape_sequences[0] == '%' && svd.escape_sequences[1] == '/')
{
if(svd.escape_sequences[2] == '@' ||
svd.escape_sequences[2] == 'C' ||
svd.escape_sequences[2] == 'E')
jolietvd = svd;
else
{
AaruLogging.WriteLine(MODULE_NAME,
Localization.Found_unknown_supplementary_volume_descriptor);
}
}
}
else
evd = true;
break;
}
case 3:
{
vpd = true;
break;
}
}
counter++;
}
DecodedVolumeDescriptor decodedVd;
var decodedJolietVd = new DecodedVolumeDescriptor();
metadata = new FileSystem();
if(pvd == null && hsvd == null && fsvd == null)
{
information = Localization.ERROR_Could_not_find_primary_volume_descriptor;
return;
}
if(highSierraInfo)
decodedVd = DecodeVolumeDescriptor(hsvd.Value);
else if(cdiInfo)
decodedVd = DecodeVolumeDescriptor(fsvd.Value);
else
decodedVd = DecodeVolumeDescriptor(pvd.Value);
if(jolietvd != null) decodedJolietVd = DecodeJolietDescriptor(jolietvd.Value);
uint rootLocation = 0;
uint rootSize = 0;
// No need to read root on CD-i, as extensions are not supported...
if(!cdiInfo)
{
rootLocation = highSierraInfo
? hsvd.Value.root_directory_record.extent
: pvd.Value.root_directory_record.extent;
if(highSierraInfo)
{
rootSize = hsvd.Value.root_directory_record.size / hsvd.Value.logical_block_size;
if(hsvd.Value.root_directory_record.size % hsvd.Value.logical_block_size > 0) rootSize++;
}
else
{
rootSize = pvd.Value.root_directory_record.size / pvd.Value.logical_block_size;
if(pvd.Value.root_directory_record.size % pvd.Value.logical_block_size > 0) rootSize++;
}
}
byte[] rootDir = [];
var rootOff = 0;
var xaExtensions = false;
var apple = false;
var susp = false;
var rrip = false;
var ziso = false;
var amiga = false;
var aaip = false;
List<ContinuationArea> contareas = [];
List<byte[]> refareas = [];
var suspInformation = new StringBuilder();
if(rootLocation + rootSize < imagePlugin.Info.Sectors)
{
errno = imagePlugin.ReadSectors(rootLocation, false, rootSize, out rootDir, out _);
if(errno != ErrorNumber.NoError) return;
}
// Walk thru root directory to see system area extensions in use
while(rootOff + Marshal.SizeOf<DirectoryRecord>() < rootDir.Length && !cdiInfo)
{
DirectoryRecord record =
Marshal.ByteArrayToStructureLittleEndian<DirectoryRecord>(rootDir,
rootOff,
Marshal.SizeOf<DirectoryRecord>());
int saOff = Marshal.SizeOf<DirectoryRecord>() + record.name_len;
saOff += saOff % 2;
int saLen = record.length - saOff;
if(saLen > 0 && rootOff + saOff + saLen <= rootDir.Length)
{
var sa = new byte[saLen];
Array.Copy(rootDir, rootOff + saOff, sa, 0, saLen);
saOff = 0;
while(saOff < saLen)
{
var noneFound = true;
if(Marshal.SizeOf<CdromXa>() + saOff <= saLen)
{
CdromXa xa = Marshal.ByteArrayToStructureBigEndian<CdromXa>(sa);
if(xa.signature == XA_MAGIC)
{
xaExtensions = true;
saOff += Marshal.SizeOf<CdromXa>();
noneFound = false;
}
}
if(saOff + 2 >= saLen) break;
var nextSignature = BigEndianBitConverter.ToUInt16(sa, saOff);
switch(nextSignature)
{
// Easy, contains size field
case APPLE_MAGIC:
apple = true;
saOff += sa[saOff + 2];
noneFound = false;
break;
// Not easy, contains size field
case APPLE_MAGIC_OLD:
apple = true;
var appleId = (AppleOldId)sa[saOff + 2];
noneFound = false;
switch(appleId)
{
case AppleOldId.ProDOS:
saOff += Marshal.SizeOf<AppleProDOSOldSystemUse>();
break;
case AppleOldId.TypeCreator:
case AppleOldId.TypeCreatorBundle:
saOff += Marshal.SizeOf<AppleHFSTypeCreatorSystemUse>();
break;
case AppleOldId.TypeCreatorIcon:
case AppleOldId.TypeCreatorIconBundle:
saOff += Marshal.SizeOf<AppleHFSIconSystemUse>();
break;
case AppleOldId.HFS:
saOff += Marshal.SizeOf<AppleHFSOldSystemUse>();
break;
}
break;
// IEEE-P1281 aka SUSP 1.12
case SUSP_INDICATOR:
susp = true;
saOff += sa[saOff + 2];
noneFound = false;
while(saOff + 2 < saLen)
{
nextSignature = BigEndianBitConverter.ToUInt16(sa, saOff);
switch(nextSignature)
{
case APPLE_MAGIC:
if(sa[saOff + 3] == 1 && sa[saOff + 2] == 7)
apple = true;
else
apple |= sa[saOff + 3] != 1;
break;
case SUSP_CONTINUATION when saOff + sa[saOff + 2] <= saLen:
var ce = new byte[sa[saOff + 2]];
Array.Copy(sa, saOff, ce, 0, ce.Length);
ContinuationArea ca =
Marshal.ByteArrayToStructureBigEndian<ContinuationArea>(ce);
contareas.Add(ca);
break;
case SUSP_REFERENCE when saOff + sa[saOff + 2] <= saLen:
var er = new byte[sa[saOff + 2]];
Array.Copy(sa, saOff, er, 0, er.Length);
refareas.Add(er);
break;
}
rrip |= nextSignature is RRIP_MAGIC
or RRIP_POSIX_ATTRIBUTES
or RRIP_POSIX_DEV_NO
or RRIP_SYMLINK
or RRIP_NAME
or RRIP_CHILDLINK
or RRIP_PARENTLINK
or RRIP_RELOCATED_DIR
or RRIP_TIMESTAMPS
or RRIP_SPARSE;
ziso |= nextSignature == ZISO_MAGIC;
amiga |= nextSignature == AMIGA_MAGIC;
aaip |= nextSignature == AAIP_MAGIC ||
nextSignature == AAIP_MAGIC_OLD && sa[saOff + 3] == 1 && sa[saOff + 2] >= 9;
saOff += sa[saOff + 2];
if(nextSignature == SUSP_TERMINATOR) break;
}
break;
}
if(noneFound) break;
}
}
rootOff += record.length;
if(record.length == 0) break;
}
foreach(ContinuationArea ca in contareas)
{
uint caLen = (ca.ca_length_be + ca.offset_be) /
(highSierraInfo ? hsvd.Value.logical_block_size : pvd.Value.logical_block_size);
if((ca.ca_length_be + ca.offset_be) %
(highSierraInfo ? hsvd.Value.logical_block_size : pvd.Value.logical_block_size) >
0)
caLen++;
errno = imagePlugin.ReadSectors(ca.block_be, false, caLen, out byte[] caSectors, out _);
if(errno != ErrorNumber.NoError) return;
var caData = new byte[ca.ca_length_be];
Array.Copy(caSectors, ca.offset_be, caData, 0, ca.ca_length_be);
var caOff = 0;
while(caOff < ca.ca_length_be)
{
var nextSignature = BigEndianBitConverter.ToUInt16(caData, caOff);
switch(nextSignature)
{
// Apple never said to include its extensions inside a continuation area, but just in case
case APPLE_MAGIC:
if(caData[caOff + 3] == 1 && caData[caOff + 2] == 7)
apple = true;
else
apple |= caData[caOff + 3] != 1;
break;
case SUSP_REFERENCE when caOff + caData[caOff + 2] <= ca.ca_length_be:
var er = new byte[caData[caOff + 2]];
Array.Copy(caData, caOff, er, 0, er.Length);
refareas.Add(er);
break;
}
rrip |= nextSignature is RRIP_MAGIC
or RRIP_POSIX_ATTRIBUTES
or RRIP_POSIX_DEV_NO
or RRIP_SYMLINK
or RRIP_NAME
or RRIP_CHILDLINK
or RRIP_PARENTLINK
or RRIP_RELOCATED_DIR
or RRIP_TIMESTAMPS
or RRIP_SPARSE;
ziso |= nextSignature == ZISO_MAGIC;
amiga |= nextSignature == AMIGA_MAGIC;
aaip |= nextSignature == AAIP_MAGIC ||
nextSignature == AAIP_MAGIC_OLD && caData[caOff + 3] == 1 && caData[caOff + 2] >= 9;
caOff += caData[caOff + 2];
}
}
if(refareas.Count > 0)
{
suspInformation.AppendLine(Localization.SYSTEM_USE_SHARING_PROTOCOL_INFORMATION_border);
suspInformation.AppendLine(Localization.SYSTEM_USE_SHARING_PROTOCOL_INFORMATION);
suspInformation.AppendLine(Localization.SYSTEM_USE_SHARING_PROTOCOL_INFORMATION_border);
counter = 1;
foreach(byte[] erb in refareas)
{
ReferenceArea er = Marshal.ByteArrayToStructureBigEndian<ReferenceArea>(erb);
string extId = encoding.GetString(erb, Marshal.SizeOf<ReferenceArea>(), er.id_len);
string extDes = encoding.GetString(erb, Marshal.SizeOf<ReferenceArea>() + er.id_len, er.des_len);
string extSrc =
encoding.GetString(erb, Marshal.SizeOf<ReferenceArea>() + er.id_len + er.des_len, er.src_len);
suspInformation.AppendFormat(Localization.Extension_0, counter).AppendLine();
suspInformation.AppendFormat("\t" + Localization.ID_0_version_1, extId, er.ext_ver).AppendLine();
suspInformation.AppendFormat("\t" + Localization.Description_0, extDes).AppendLine();
suspInformation.AppendFormat("\t" + Localization.Source_0, extSrc).AppendLine();
counter++;
}
}
errno = imagePlugin.ReadSector(0 + partition.Start, false, out byte[] ipbinSector, out _);
if(errno != ErrorNumber.NoError) return;
CD.IPBin? segaCd = CD.DecodeIPBin(ipbinSector);
Saturn.IPBin? saturn = Saturn.DecodeIPBin(ipbinSector);
Dreamcast.IPBin? dreamcast = Dreamcast.DecodeIPBin(ipbinSector);
if(highSierraInfo)
isoMetadata.AppendLine(Localization.High_Sierra_Format_file_system);
else if(cdiInfo)
isoMetadata.AppendLine(Localization.CD_i_file_system);
else
isoMetadata.AppendLine(Localization.ISO9660_file_system);
if(xaExtensions) isoMetadata.AppendLine(Localization.CD_ROM_XA_extensions_present);
if(amiga) isoMetadata.AppendLine(Localization.Amiga_extensions_present);
if(apple) isoMetadata.AppendLine(Localization.Apple_extensions_present);
if(jolietvd != null) isoMetadata.AppendLine(Localization.Joliet_extensions_present);
if(susp) isoMetadata.AppendLine(Localization.System_Use_Sharing_Protocol_present);
if(rrip) isoMetadata.AppendLine(Localization.Rock_Ridge_Interchange_Protocol_present);
if(aaip) isoMetadata.AppendLine(Localization.Arbitrary_Attribute_Interchange_Protocol_present);
if(ziso) isoMetadata.AppendLine(Localization.zisofs_compression_present);
if(evd) isoMetadata.AppendLine(Localization.Contains_Enhanced_Volume_Descriptor);
if(vpd) isoMetadata.AppendLine(Localization.Contains_Volume_Partition_Descriptor);
if(bvd != null)
isoMetadata.AppendFormat(Localization.Disc_bootable_following_0_specifications, bootSpec).AppendLine();
if(segaCd != null)
{
isoMetadata.AppendLine(Localization.This_is_a_SegaCD_MegaCD_disc);
isoMetadata.AppendLine(CD.Prettify(segaCd));
}
if(saturn != null)
{
isoMetadata.AppendLine(Localization.This_is_a_Sega_Saturn_disc);
isoMetadata.AppendLine(Saturn.Prettify(saturn));
}
if(dreamcast != null)
{
isoMetadata.AppendLine(Localization.This_is_a_Sega_Dreamcast_disc);
isoMetadata.AppendLine(Dreamcast.Prettify(dreamcast));
}
if(cdiInfo)
{
isoMetadata.AppendLine(Localization.FILE_STRUCTURE_VOLUME_DESCRIPTOR_INFORMATION_border);
isoMetadata.AppendLine(Localization.FILE_STRUCTURE_VOLUME_DESCRIPTOR_INFORMATION);
isoMetadata.AppendLine(Localization.FILE_STRUCTURE_VOLUME_DESCRIPTOR_INFORMATION_border);
}
else
{
isoMetadata.AppendLine(Localization.VOLUME_DESCRIPTOR_INFORMATION_border);
isoMetadata.AppendLine(Localization.VOLUME_DESCRIPTOR_INFORMATION);
isoMetadata.AppendLine(Localization.VOLUME_DESCRIPTOR_INFORMATION_border);
}
isoMetadata.AppendFormat(Localization.System_identifier_0, decodedVd.SystemIdentifier).AppendLine();
isoMetadata.AppendFormat(Localization.Volume_identifier_0, decodedVd.VolumeIdentifier).AppendLine();
isoMetadata.AppendFormat(Localization.Volume_set_identifier_0, decodedVd.VolumeSetIdentifier).AppendLine();
isoMetadata.AppendFormat(Localization.Publisher_identifier_0, decodedVd.PublisherIdentifier).AppendLine();
isoMetadata.AppendFormat(Localization.Data_preparer_identifier_0, decodedVd.DataPreparerIdentifier)
.AppendLine();
isoMetadata.AppendFormat(Localization.Application_identifier_0, decodedVd.ApplicationIdentifier).AppendLine();
isoMetadata.AppendFormat(Localization.Volume_creation_date_0, decodedVd.CreationTime).AppendLine();
if(decodedVd.HasModificationTime)
isoMetadata.AppendFormat(Localization.Volume_modification_date_0, decodedVd.ModificationTime).AppendLine();
else
isoMetadata.AppendFormat(Localization.Volume_has_not_been_modified).AppendLine();
if(decodedVd.HasExpirationTime)
isoMetadata.AppendFormat(Localization.Volume_expiration_date_0, decodedVd.ExpirationTime).AppendLine();
else
isoMetadata.AppendFormat(Localization.Volume_does_not_expire).AppendLine();
if(decodedVd.HasEffectiveTime)
isoMetadata.AppendFormat(Localization.Volume_effective_date_0, decodedVd.EffectiveTime).AppendLine();
else
isoMetadata.AppendFormat(Localization.Volume_has_always_been_effective).AppendLine();
isoMetadata.AppendFormat(Localization.Volume_has_0_blocks_of_1_bytes_each,
decodedVd.Blocks,
decodedVd.BlockSize)
.AppendLine();
if(jolietvd != null)
{
isoMetadata.AppendLine(Localization.JOLIET_VOLUME_DESCRIPTOR_INFORMATION_border);
isoMetadata.AppendLine(Localization.JOLIET_VOLUME_DESCRIPTOR_INFORMATION);
isoMetadata.AppendLine(Localization.JOLIET_VOLUME_DESCRIPTOR_INFORMATION_border);
isoMetadata.AppendFormat(Localization.System_identifier_0, decodedJolietVd.SystemIdentifier).AppendLine();
isoMetadata.AppendFormat(Localization.Volume_identifier_0, decodedJolietVd.VolumeIdentifier).AppendLine();
isoMetadata.AppendFormat(Localization.Volume_set_identifier_0, decodedJolietVd.VolumeSetIdentifier)
.AppendLine();
isoMetadata.AppendFormat(Localization.Publisher_identifier_0, decodedJolietVd.PublisherIdentifier)
.AppendLine();
isoMetadata.AppendFormat(Localization.Data_preparer_identifier_0, decodedJolietVd.DataPreparerIdentifier)
.AppendLine();
isoMetadata.AppendFormat(Localization.Application_identifier_0, decodedJolietVd.ApplicationIdentifier)
.AppendLine();
isoMetadata.AppendFormat(Localization.Volume_creation_date_0, decodedJolietVd.CreationTime).AppendLine();
if(decodedJolietVd.HasModificationTime)
{
isoMetadata.AppendFormat(Localization.Volume_modification_date_0, decodedJolietVd.ModificationTime)
.AppendLine();
}
else
isoMetadata.AppendFormat(Localization.Volume_has_not_been_modified).AppendLine();
if(decodedJolietVd.HasExpirationTime)
{
isoMetadata.AppendFormat(Localization.Volume_expiration_date_0, decodedJolietVd.ExpirationTime)
.AppendLine();
}
else
isoMetadata.AppendFormat(Localization.Volume_does_not_expire).AppendLine();
if(decodedJolietVd.HasEffectiveTime)
{
isoMetadata.AppendFormat(Localization.Volume_effective_date_0, decodedJolietVd.EffectiveTime)
.AppendLine();
}
else
isoMetadata.AppendFormat(Localization.Volume_has_always_been_effective).AppendLine();
}
if(torito != null)
{
errno = imagePlugin.ReadSector(torito.Value.catalog_sector + partition.Start, false, out vdSector, out _);
if(errno != ErrorNumber.NoError) return;
var toritoOff = 0;
if(vdSector[toritoOff] != 1) goto exit_torito;
ElToritoValidationEntry valentry =
Marshal.ByteArrayToStructureLittleEndian<ElToritoValidationEntry>(vdSector,
toritoOff,
EL_TORITO_ENTRY_SIZE);
if(valentry.signature != EL_TORITO_MAGIC) goto exit_torito;
toritoOff = EL_TORITO_ENTRY_SIZE;
ElToritoInitialEntry initialEntry =
Marshal.ByteArrayToStructureLittleEndian<ElToritoInitialEntry>(vdSector,
toritoOff,
EL_TORITO_ENTRY_SIZE);
initialEntry.boot_type = (ElToritoEmulation)((byte)initialEntry.boot_type & 0xF);
AaruLogging.Debug(MODULE_NAME, "initialEntry.load_rba = {0}", initialEntry.load_rba);
AaruLogging.Debug(MODULE_NAME, "initialEntry.sector_count = {0}", initialEntry.sector_count);
byte[] bootImage = null;
if(initialEntry.load_rba + partition.Start + initialEntry.sector_count - 1 <= partition.End)
{
imagePlugin.ReadSectors(initialEntry.load_rba + partition.Start,
false,
initialEntry.sector_count,
out bootImage,
out _);
}
isoMetadata.AppendLine(Localization.EL_TORITO_INFORMATION_border);
isoMetadata.AppendLine(Localization.EL_TORITO_INFORMATION);
isoMetadata.AppendLine(Localization.EL_TORITO_INFORMATION_border);
isoMetadata.AppendLine(Localization.Initial_entry);
isoMetadata.AppendFormat("\t" + Localization.Developer_ID_0, encoding.GetString(valentry.developer_id))
.AppendLine();
if(initialEntry.bootable == ElToritoIndicator.Bootable)
{
isoMetadata.AppendFormat("\t" + Localization.Bootable_on_0, valentry.platform_id).AppendLine();
isoMetadata.AppendFormat("\t" + Localization.Bootable_image_starts_at_sector_0_and_runs_for_1_sectors,
initialEntry.load_rba,
initialEntry.sector_count)
.AppendLine();
if(valentry.platform_id == ElToritoPlatform.x86)
{
isoMetadata.AppendFormat("\t" + Localization.Bootable_image_will_be_loaded_at_segment_0,
initialEntry.load_seg == 0 ? 0x7C0 : initialEntry.load_seg)
.AppendLine();
}
else
{
isoMetadata.AppendFormat("\t" + Localization.Bootable_image_will_be_loaded_at_0,
(uint)initialEntry.load_seg * 10)
.AppendLine();
}
switch(initialEntry.boot_type)
{
case ElToritoEmulation.None:
isoMetadata.AppendLine("\t" + Localization.Image_uses_no_emulation);
break;
case ElToritoEmulation.Md2Hd:
isoMetadata.AppendLine("\t" + Localization.Image_emulates_a_high_density_MD2HD_floppy);
break;
case ElToritoEmulation.Mf2Hd:
isoMetadata.AppendLine("\t" + Localization.Image_emulates_a_high_density_MF2HD_floppy);
break;
case ElToritoEmulation.Mf2Ed:
isoMetadata.AppendLine("\t" + Localization.Image_emulates_a_extra_density_MF2ED_floppy);
break;
default:
isoMetadata.AppendFormat("\t" + Localization.Image_uses_unknown_emulation_type_0,
(byte)initialEntry.boot_type)
.AppendLine();
break;
}
isoMetadata.AppendFormat("\t" + Localization.System_type_0, initialEntry.system_type).AppendLine();
if(bootImage != null)
{
isoMetadata.AppendFormat("\t" + Localization.Bootable_image_SHA1_0,
Sha1Context.Data(bootImage, out _))
.AppendLine();
}
}
else
isoMetadata.AppendLine("\t" + Localization.Not_bootable);
toritoOff += EL_TORITO_ENTRY_SIZE;
const int sectionCounter = 2;
while(toritoOff < vdSector.Length &&
(vdSector[toritoOff] == (byte)ElToritoIndicator.Header ||
vdSector[toritoOff] == (byte)ElToritoIndicator.LastHeader))
{
ElToritoSectionHeaderEntry sectionHeader =
Marshal.ByteArrayToStructureLittleEndian<ElToritoSectionHeaderEntry>(vdSector,
toritoOff,
EL_TORITO_ENTRY_SIZE);
toritoOff += EL_TORITO_ENTRY_SIZE;
isoMetadata.AppendFormat(Localization.Boot_section_0, sectionCounter);
isoMetadata.AppendFormat("\t" + Localization.Section_ID_0, encoding.GetString(sectionHeader.identifier))
.AppendLine();
for(var entryCounter = 1;
entryCounter <= sectionHeader.entries && toritoOff < vdSector.Length;
entryCounter++)
{
ElToritoSectionEntry sectionEntry =
Marshal.ByteArrayToStructureLittleEndian<ElToritoSectionEntry>(vdSector,
toritoOff,
EL_TORITO_ENTRY_SIZE);
toritoOff += EL_TORITO_ENTRY_SIZE;
isoMetadata.AppendFormat("\t" + Localization.Entry_0, entryCounter);
if(sectionEntry.bootable == ElToritoIndicator.Bootable)
{
bootImage = null;
if(sectionEntry.load_rba + partition.Start + sectionEntry.sector_count - 1 <= partition.End)
{
imagePlugin.ReadSectors(sectionEntry.load_rba + partition.Start,
false,
sectionEntry.sector_count,
out bootImage,
out _);
}
isoMetadata.AppendFormat("\t\t" + Localization.Bootable_on_0, sectionHeader.platform_id)
.AppendLine();
isoMetadata
.AppendFormat("\t\t" + Localization.Bootable_image_starts_at_sector_0_and_runs_for_1_sectors,
sectionEntry.load_rba,
sectionEntry.sector_count)
.AppendLine();
if(valentry.platform_id == ElToritoPlatform.x86)
{
isoMetadata.AppendFormat("\t\t" + Localization.Bootable_image_will_be_loaded_at_segment_0,
sectionEntry.load_seg == 0 ? 0x7C0 : sectionEntry.load_seg)
.AppendLine();
}
else
{
isoMetadata.AppendFormat("\t\t" + Localization.Bootable_image_will_be_loaded_at_0,
(uint)sectionEntry.load_seg * 10)
.AppendLine();
}
switch((ElToritoEmulation)((byte)sectionEntry.boot_type & 0xF))
{
case ElToritoEmulation.None:
isoMetadata.AppendLine("\t\t" + Localization.Image_uses_no_emulation);
break;
case ElToritoEmulation.Md2Hd:
isoMetadata.AppendLine("\t\t" +
Localization.Image_emulates_a_high_density_MD2HD_floppy);
break;
case ElToritoEmulation.Mf2Hd:
isoMetadata.AppendLine("\t\t" +
Localization.Image_emulates_a_high_density_MF2HD_floppy);
break;
case ElToritoEmulation.Mf2Ed:
isoMetadata.AppendLine("\t\t" +
Localization.Image_emulates_a_extra_density_MF2ED_floppy);
break;
default:
isoMetadata.AppendFormat("\t\t" + Localization.Image_uses_unknown_emulation_type_0,
(byte)initialEntry.boot_type)
.AppendLine();
break;
}
isoMetadata.AppendFormat("\t\t" + Localization.Selection_criteria_type_0,
sectionEntry.selection_criteria_type)
.AppendLine();
isoMetadata.AppendFormat("\t\t" + Localization.System_type_0, sectionEntry.system_type)
.AppendLine();
if(bootImage != null)
{
isoMetadata.AppendFormat("\t\t" + Localization.Bootable_image_SHA1_0,
Sha1Context.Data(bootImage, out _))
.AppendLine();
}
}
else
isoMetadata.AppendLine("\t\t" + Localization.Not_bootable);
var flags = (ElToritoFlags)((byte)sectionEntry.boot_type & 0xF0);
if(flags.HasFlag(ElToritoFlags.ATAPI))
isoMetadata.AppendLine("\t\t" + Localization.Image_contains_ATAPI_drivers);
if(flags.HasFlag(ElToritoFlags.SCSI))
isoMetadata.AppendLine("\t\t" + Localization.Image_contains_SCSI_drivers);
if(!flags.HasFlag(ElToritoFlags.Continued)) continue;
while(toritoOff < vdSector.Length)
{
ElToritoSectionEntryExtension sectionExtension =
Marshal.ByteArrayToStructureLittleEndian<ElToritoSectionEntryExtension>(vdSector,
toritoOff,
EL_TORITO_ENTRY_SIZE);
toritoOff += EL_TORITO_ENTRY_SIZE;
if(!sectionExtension.extension_flags.HasFlag(ElToritoFlags.Continued)) break;
}
}
if(sectionHeader.header_id == ElToritoIndicator.LastHeader) break;
}
}
exit_torito:
if(refareas.Count > 0) isoMetadata.Append(suspInformation);
if(highSierraInfo)
metadata.Type = FS_TYPE_HSF;
else if(cdiInfo)
metadata.Type = FS_TYPE_CDI;
else
metadata.Type = FS_TYPE_ISO;
if(jolietvd != null)
{
metadata.VolumeName = decodedJolietVd.VolumeIdentifier;
if(string.IsNullOrEmpty(decodedJolietVd.SystemIdentifier) ||
decodedVd.SystemIdentifier.Length > decodedJolietVd.SystemIdentifier.Length)
metadata.SystemIdentifier = decodedVd.SystemIdentifier;
else
{
metadata.SystemIdentifier = string.IsNullOrEmpty(decodedJolietVd.SystemIdentifier)
? null
: decodedJolietVd.SystemIdentifier;
}
if(string.IsNullOrEmpty(decodedJolietVd.VolumeSetIdentifier) ||
decodedVd.VolumeSetIdentifier.Length > decodedJolietVd.VolumeSetIdentifier.Length)
metadata.VolumeSetIdentifier = decodedVd.VolumeSetIdentifier;
else
{
metadata.VolumeSetIdentifier = string.IsNullOrEmpty(decodedJolietVd.VolumeSetIdentifier)
? null
: decodedJolietVd.VolumeSetIdentifier;
}
if(string.IsNullOrEmpty(decodedJolietVd.PublisherIdentifier) ||
decodedVd.PublisherIdentifier.Length > decodedJolietVd.PublisherIdentifier.Length)
metadata.PublisherIdentifier = decodedVd.PublisherIdentifier;
else
{
metadata.PublisherIdentifier = string.IsNullOrEmpty(decodedJolietVd.PublisherIdentifier)
? null
: decodedJolietVd.PublisherIdentifier;
}
if(string.IsNullOrEmpty(decodedJolietVd.DataPreparerIdentifier) ||
decodedVd.DataPreparerIdentifier.Length > decodedJolietVd.DataPreparerIdentifier.Length)
metadata.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier;
else
{
metadata.DataPreparerIdentifier = string.IsNullOrEmpty(decodedJolietVd.DataPreparerIdentifier)
? null
: decodedJolietVd.DataPreparerIdentifier;
}
if(string.IsNullOrEmpty(decodedJolietVd.ApplicationIdentifier) ||
decodedVd.ApplicationIdentifier.Length > decodedJolietVd.ApplicationIdentifier.Length)
metadata.ApplicationIdentifier = decodedVd.ApplicationIdentifier;
else
{
metadata.ApplicationIdentifier = string.IsNullOrEmpty(decodedJolietVd.ApplicationIdentifier)
? null
: decodedJolietVd.ApplicationIdentifier;
}
metadata.CreationDate = decodedJolietVd.CreationTime;
if(decodedJolietVd.HasModificationTime) metadata.ModificationDate = decodedJolietVd.ModificationTime;
if(decodedJolietVd.HasExpirationTime) metadata.ExpirationDate = decodedJolietVd.ExpirationTime;
if(decodedJolietVd.HasEffectiveTime) metadata.EffectiveDate = decodedJolietVd.EffectiveTime;
}
else
{
metadata.SystemIdentifier = decodedVd.SystemIdentifier;
metadata.VolumeName = decodedVd.VolumeIdentifier;
metadata.VolumeSetIdentifier = decodedVd.VolumeSetIdentifier;
metadata.PublisherIdentifier = decodedVd.PublisherIdentifier;
metadata.DataPreparerIdentifier = decodedVd.DataPreparerIdentifier;
metadata.ApplicationIdentifier = decodedVd.ApplicationIdentifier;
metadata.CreationDate = decodedVd.CreationTime;
if(decodedVd.HasModificationTime) metadata.ModificationDate = decodedVd.ModificationTime;
if(decodedVd.HasExpirationTime) metadata.ExpirationDate = decodedVd.ExpirationTime;
if(decodedVd.HasEffectiveTime) metadata.EffectiveDate = decodedVd.EffectiveTime;
}
metadata.Bootable |= bvd != null || segaCd != null || saturn != null || dreamcast != null;
metadata.Clusters = decodedVd.Blocks;
metadata.ClusterSize = decodedVd.BlockSize;
information = isoMetadata.ToString();
}
#endregion
}
Reference in New Issue View Git Blame Copy Permalink