mirror of
https://github.com/SabreTools/BinaryObjectScanner.git
synced 2026-02-13 13:45:57 +00:00
753 lines
38 KiB
C#
753 lines
38 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace BinaryObjectScanner.Wrappers
|
|
{
|
|
public partial class InstallShieldCabinet : WrapperBase
|
|
{
|
|
#region Descriptive Properties
|
|
|
|
/// <inheritdoc/>
|
|
public override string Description => "InstallShield Cabinet";
|
|
|
|
#endregion
|
|
|
|
#region Pass-Through Properties
|
|
|
|
#region Common Header
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.CommonHeader.Signature"/>
|
|
public string Signature => _cabinet.CommonHeader.Signature;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.CommonHeader.Version"/>
|
|
public uint Version => _cabinet.CommonHeader.Version;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.CommonHeader.VolumeInfo"/>
|
|
public uint VolumeInfo => _cabinet.CommonHeader.VolumeInfo;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.CommonHeader.DescriptorOffset"/>
|
|
public uint DescriptorOffset => _cabinet.CommonHeader.DescriptorOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.CommonHeader.DescriptorSize"/>
|
|
public uint DescriptorSize => _cabinet.CommonHeader.DescriptorSize;
|
|
|
|
#endregion
|
|
|
|
#region Volume Header
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.DataOffset"/>
|
|
public uint DataOffset => _cabinet.VolumeHeader.DataOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.DataOffsetHigh"/>
|
|
public uint DataOffsetHigh => _cabinet.VolumeHeader.DataOffsetHigh;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.FirstFileIndex"/>
|
|
public uint FirstFileIndex => _cabinet.VolumeHeader.FirstFileIndex;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.LastFileIndex"/>
|
|
public uint LastFileIndex => _cabinet.VolumeHeader.LastFileIndex;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.FirstFileOffset"/>
|
|
public uint FirstFileOffset => _cabinet.VolumeHeader.FirstFileOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.FirstFileOffsetHigh"/>
|
|
public uint FirstFileOffsetHigh => _cabinet.VolumeHeader.FirstFileOffsetHigh;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.FirstFileSizeExpanded"/>
|
|
public uint FirstFileSizeExpanded => _cabinet.VolumeHeader.FirstFileSizeExpanded;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.FirstFileSizeExpandedHigh"/>
|
|
public uint FirstFileSizeExpandedHigh => _cabinet.VolumeHeader.FirstFileSizeExpandedHigh;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.FirstFileSizeCompressed"/>
|
|
public uint FirstFileSizeCompressed => _cabinet.VolumeHeader.FirstFileSizeCompressed;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.FirstFileSizeCompressedHigh"/>
|
|
public uint FirstFileSizeCompressedHigh => _cabinet.VolumeHeader.FirstFileSizeCompressedHigh;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.LastFileOffset"/>
|
|
public uint LastFileOffset => _cabinet.VolumeHeader.LastFileOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.LastFileOffsetHigh"/>
|
|
public uint LastFileOffsetHigh => _cabinet.VolumeHeader.LastFileOffsetHigh;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.LastFileSizeExpanded"/>
|
|
public uint LastFileSizeExpanded => _cabinet.VolumeHeader.LastFileSizeExpanded;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.LastFileSizeExpandedHigh"/>
|
|
public uint LastFileSizeExpandedHigh => _cabinet.VolumeHeader.LastFileSizeExpandedHigh;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.LastFileSizeCompressed"/>
|
|
public uint LastFileSizeCompressed => _cabinet.VolumeHeader.LastFileSizeCompressed;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.VolumeHeader.LastFileSizeCompressedHigh"/>
|
|
public uint LastFileSizeCompressedHigh => _cabinet.VolumeHeader.LastFileSizeCompressedHigh;
|
|
|
|
#endregion
|
|
|
|
#region Descriptor
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.StringsOffset"/>
|
|
public uint StringsOffset => _cabinet.Descriptor.StringsOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved0"/>
|
|
public byte[] Reserved0 => _cabinet.Descriptor.Reserved0;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.ComponentListOffset"/>
|
|
public uint ComponentListOffset => _cabinet.Descriptor.ComponentListOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.FileTableOffset"/>
|
|
public uint FileTableOffset => _cabinet.Descriptor.FileTableOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved1"/>
|
|
public byte[] Reserved1 => _cabinet.Descriptor.Reserved1;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.FileTableSize"/>
|
|
public uint FileTableSize => _cabinet.Descriptor.FileTableSize;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.FileTableSize2"/>
|
|
public uint FileTableSize2 => _cabinet.Descriptor.FileTableSize2;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.DirectoryCount"/>
|
|
public ushort DirectoryCount => _cabinet.Descriptor.DirectoryCount;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved2"/>
|
|
public byte[] Reserved2 => _cabinet.Descriptor.Reserved2;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved3"/>
|
|
public byte[] Reserved3 => _cabinet.Descriptor.Reserved3;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved4"/>
|
|
public byte[] Reserved4 => _cabinet.Descriptor.Reserved4;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.FileCount"/>
|
|
public uint FileCount => _cabinet.Descriptor.FileCount;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.FileTableOffset2"/>
|
|
public uint FileTableOffset2 => _cabinet.Descriptor.FileTableOffset2;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.ComponentTableInfoCount"/>
|
|
public ushort ComponentTableInfoCount => _cabinet.Descriptor.ComponentTableInfoCount;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.ComponentTableOffset"/>
|
|
public uint ComponentTableOffset => _cabinet.Descriptor.ComponentTableOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved5"/>
|
|
public byte[] Reserved5 => _cabinet.Descriptor.Reserved5;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved6"/>
|
|
public byte[] Reserved6 => _cabinet.Descriptor.Reserved6;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.FileGroupOffsets"/>
|
|
public uint[] D_FileGroupOffsets => _cabinet.Descriptor.FileGroupOffsets;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.ComponentOffsets"/>
|
|
public uint[] D_ComponentOffsets => _cabinet.Descriptor.ComponentOffsets;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.SetupTypesOffset"/>
|
|
public uint SetupTypesOffset => _cabinet.Descriptor.SetupTypesOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.SetupTableOffset"/>
|
|
public uint SetupTableOffset => _cabinet.Descriptor.SetupTableOffset;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved7"/>
|
|
public byte[] Reserved7 => _cabinet.Descriptor.Reserved7;
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Descriptor.Reserved8"/>
|
|
public byte[] Reserved8 => _cabinet.Descriptor.Reserved8;
|
|
|
|
#endregion
|
|
|
|
#region File Descriptor Offsets
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Cabinet.FileDescriptorOffsets"/>
|
|
public uint[] FileDescriptorOffsets => _cabinet.FileDescriptorOffsets;
|
|
|
|
#endregion
|
|
|
|
#region Directory Descriptors
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Cabinet.DirectoryNames"/>
|
|
public string[] DirectoryNames => _cabinet.DirectoryNames;
|
|
|
|
#endregion
|
|
|
|
#region File Descriptors
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Cabinet.FileDescriptors"/>
|
|
public Models.InstallShieldCabinet.FileDescriptor[] FileDescriptors => _cabinet.FileDescriptors;
|
|
|
|
#endregion
|
|
|
|
#region File Group Offsets
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Cabinet.FileGroupOffsets"/>
|
|
public Dictionary<long, Models.InstallShieldCabinet.OffsetList> FileGroupOffsets => _cabinet.FileGroupOffsets;
|
|
|
|
#endregion
|
|
|
|
#region File Groups
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Cabinet.FileGroups"/>
|
|
public Models.InstallShieldCabinet.FileGroup[] FileGroups => _cabinet.FileGroups;
|
|
|
|
#endregion
|
|
|
|
#region Component Offsets
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Cabinet.ComponentOffsets"/>
|
|
public Dictionary<long, Models.InstallShieldCabinet.OffsetList> ComponentOffsets => _cabinet.ComponentOffsets;
|
|
|
|
#endregion
|
|
|
|
#region Components
|
|
|
|
/// <inheritdoc cref="Models.InstallShieldCabinet.Cabinet.Components"/>
|
|
public Models.InstallShieldCabinet.Component[] Components => _cabinet.Components;
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Extension Properties
|
|
|
|
/// <summary>
|
|
/// The major version of the cabinet
|
|
/// </summary>
|
|
public int MajorVersion
|
|
{
|
|
get
|
|
{
|
|
uint majorVersion = Version;
|
|
if (majorVersion >> 24 == 1)
|
|
{
|
|
majorVersion = (majorVersion >> 12) & 0x0F;
|
|
}
|
|
else if (majorVersion >> 24 == 2 || majorVersion >> 24 == 4)
|
|
{
|
|
majorVersion = majorVersion & 0xFFFF;
|
|
if (majorVersion != 0)
|
|
majorVersion /= 100;
|
|
}
|
|
|
|
return (int)majorVersion;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Instance Variables
|
|
|
|
/// <summary>
|
|
/// Internal representation of the cabinet
|
|
/// </summary>
|
|
private Models.InstallShieldCabinet.Cabinet _cabinet;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
/// <summary>
|
|
/// Private constructor
|
|
/// </summary>
|
|
private InstallShieldCabinet() { }
|
|
|
|
/// <summary>
|
|
/// Create an InstallShield Cabinet from a byte array and offset
|
|
/// </summary>
|
|
/// <param name="data">Byte array representing the cabinet</param>
|
|
/// <param name="offset">Offset within the array to parse</param>
|
|
/// <returns>A cabinet wrapper on success, null on failure</returns>
|
|
public static InstallShieldCabinet Create(byte[] data, int offset)
|
|
{
|
|
// If the data is invalid
|
|
if (data == null)
|
|
return null;
|
|
|
|
// If the offset is out of bounds
|
|
if (offset < 0 || offset >= data.Length)
|
|
return null;
|
|
|
|
// Create a memory stream and use that
|
|
MemoryStream dataStream = new MemoryStream(data, offset, data.Length - offset);
|
|
return Create(dataStream);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a InstallShield Cabinet from a Stream
|
|
/// </summary>
|
|
/// <param name="data">Stream representing the cabinet</param>
|
|
/// <returns>A cabinet wrapper on success, null on failure</returns>
|
|
public static InstallShieldCabinet Create(Stream data)
|
|
{
|
|
// If the data is invalid
|
|
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
|
|
return null;
|
|
|
|
var cabinet = Builders.InstallShieldCabinet.ParseCabinet(data);
|
|
if (cabinet == null)
|
|
return null;
|
|
|
|
var wrapper = new InstallShieldCabinet
|
|
{
|
|
_cabinet = cabinet,
|
|
_dataSource = DataSource.Stream,
|
|
_streamData = data,
|
|
};
|
|
return wrapper;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Printing
|
|
|
|
/// <inheritdoc/>
|
|
public override StringBuilder PrettyPrint()
|
|
{
|
|
StringBuilder builder = new StringBuilder();
|
|
|
|
builder.AppendLine("InstallShield Cabinet Information:");
|
|
builder.AppendLine("-------------------------");
|
|
builder.AppendLine();
|
|
|
|
// Headers
|
|
PrintCommonHeader(builder);
|
|
PrintVolumeHeader(builder);
|
|
PrintDescriptor(builder);
|
|
|
|
// File Descriptors
|
|
PrintFileDescriptorOffsets(builder);
|
|
PrintDirectoryNames(builder);
|
|
PrintFileDescriptors(builder);
|
|
|
|
// File Groups
|
|
PrintFileGroupOffsets(builder);
|
|
PrintFileGroups(builder);
|
|
|
|
// Components
|
|
PrintComponentOffsets(builder);
|
|
PrintComponents(builder);
|
|
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print common header information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintCommonHeader(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Common Header Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
builder.AppendLine($" Signature: {Signature}");
|
|
builder.AppendLine($" Version: {Version} (0x{Version:X}) [{MajorVersion}]");
|
|
builder.AppendLine($" Volume info: {VolumeInfo} (0x{VolumeInfo:X})");
|
|
builder.AppendLine($" Descriptor offset: {DescriptorOffset} (0x{DescriptorOffset:X})");
|
|
builder.AppendLine($" Descriptor size: {DescriptorSize} (0x{DescriptorSize:X})");
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print volume header information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintVolumeHeader(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Volume Header Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (MajorVersion <= 5)
|
|
{
|
|
builder.AppendLine($" Data offset: {DataOffset} (0x{DataOffset:X})");
|
|
builder.AppendLine($" First file index: {FirstFileIndex} (0x{FirstFileIndex:X})");
|
|
builder.AppendLine($" Last file index: {LastFileIndex} (0x{LastFileIndex:X})");
|
|
builder.AppendLine($" First file offset: {FirstFileOffset} (0x{FirstFileOffset:X})");
|
|
builder.AppendLine($" First file size expanded: {FirstFileSizeExpanded} (0x{FirstFileSizeExpanded:X})");
|
|
builder.AppendLine($" First file size compressed: {FirstFileSizeCompressed} (0x{FirstFileSizeCompressed:X})");
|
|
builder.AppendLine($" Last file offset: {LastFileOffset} (0x{LastFileOffset:X})");
|
|
builder.AppendLine($" Last file size expanded: {LastFileSizeExpanded} (0x{LastFileSizeExpanded:X})");
|
|
builder.AppendLine($" Last file size compressed: {LastFileSizeCompressed} (0x{LastFileSizeCompressed:X})");
|
|
}
|
|
else
|
|
{
|
|
// TODO: Should standard and high values be combined?
|
|
builder.AppendLine($" Data offset: {DataOffset} (0x{DataOffset:X})");
|
|
builder.AppendLine($" Data offset high: {DataOffsetHigh} (0x{DataOffsetHigh:X})");
|
|
builder.AppendLine($" First file index: {FirstFileIndex} (0x{FirstFileIndex:X})");
|
|
builder.AppendLine($" Last file index: {LastFileIndex} (0x{LastFileIndex:X})");
|
|
builder.AppendLine($" First file offset: {FirstFileOffset} (0x{FirstFileOffset:X})");
|
|
builder.AppendLine($" First file offset high: {FirstFileOffsetHigh} (0x{FirstFileOffsetHigh:X})");
|
|
builder.AppendLine($" First file size expanded: {FirstFileSizeExpanded} (0x{FirstFileSizeExpanded:X})");
|
|
builder.AppendLine($" First file size expanded high: {FirstFileSizeExpandedHigh} (0x{FirstFileSizeExpandedHigh:X})");
|
|
builder.AppendLine($" First file size compressed: {FirstFileSizeCompressed} (0x{FirstFileSizeCompressed:X})");
|
|
builder.AppendLine($" First file size compressed high: {FirstFileSizeCompressedHigh} (0x{FirstFileSizeCompressedHigh:X})");
|
|
builder.AppendLine($" Last file offset: {LastFileOffset} (0x{LastFileOffset:X})");
|
|
builder.AppendLine($" Last file offset high: {LastFileOffsetHigh} (0x{LastFileOffsetHigh:X})");
|
|
builder.AppendLine($" Last file size expanded: {LastFileSizeExpanded} (0x{LastFileSizeExpanded:X})");
|
|
builder.AppendLine($" Last file size expanded high: {LastFileSizeExpandedHigh} (0x{LastFileSizeExpandedHigh:X})");
|
|
builder.AppendLine($" Last file size compressed: {LastFileSizeCompressed} (0x{LastFileSizeCompressed:X})");
|
|
builder.AppendLine($" Last file size compressed high: {LastFileSizeCompressedHigh} (0x{LastFileSizeCompressedHigh:X})");
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print descriptor information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintDescriptor(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Descriptor Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
builder.AppendLine($" Strings offset: {StringsOffset} (0x{StringsOffset:X})");
|
|
builder.AppendLine($" Reserved 0: {BitConverter.ToString(Reserved0).Replace('-', ' ')}");
|
|
builder.AppendLine($" Component list offset: {ComponentListOffset} (0x{ComponentListOffset:X})");
|
|
builder.AppendLine($" File table offset: {FileTableOffset} (0x{FileTableOffset:X})");
|
|
builder.AppendLine($" Reserved 1: {BitConverter.ToString(Reserved1).Replace('-', ' ')}");
|
|
builder.AppendLine($" File table size: {FileTableSize} (0x{FileTableSize:X})");
|
|
builder.AppendLine($" File table size 2: {FileTableSize2} (0x{FileTableSize2:X})");
|
|
builder.AppendLine($" Directory count: {DirectoryCount} (0x{DirectoryCount:X})");
|
|
builder.AppendLine($" Reserved 2: {BitConverter.ToString(Reserved2).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 3: {BitConverter.ToString(Reserved3).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 4: {BitConverter.ToString(Reserved4).Replace('-', ' ')}");
|
|
builder.AppendLine($" File count: {FileCount} (0x{FileCount:X})");
|
|
builder.AppendLine($" File table offset 2: {FileTableOffset2} (0x{FileTableOffset2:X})");
|
|
builder.AppendLine($" Component table info count: {ComponentTableInfoCount} (0x{ComponentTableInfoCount:X})");
|
|
builder.AppendLine($" Component table offset: {ComponentTableOffset} (0x{ComponentTableOffset:X})");
|
|
builder.AppendLine($" Reserved 5: {BitConverter.ToString(Reserved5).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 6: {BitConverter.ToString(Reserved6).Replace('-', ' ')}");
|
|
builder.AppendLine();
|
|
|
|
builder.AppendLine($" File group offsets:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (D_FileGroupOffsets == null || D_FileGroupOffsets.Length == 0)
|
|
{
|
|
builder.AppendLine(" No file group offsets");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < D_FileGroupOffsets.Length; i++)
|
|
{
|
|
builder.AppendLine($" File Group Offset {i}: {D_FileGroupOffsets[i]} (0x{D_FileGroupOffsets[i]:X})");
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
|
|
builder.AppendLine($" Component offsets:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (D_ComponentOffsets == null || D_ComponentOffsets.Length == 0)
|
|
{
|
|
builder.AppendLine(" No component offsets");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < D_ComponentOffsets.Length; i++)
|
|
{
|
|
builder.AppendLine($" Component Offset {i}: {D_ComponentOffsets[i]} (0x{D_ComponentOffsets[i]:X})");
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
|
|
builder.AppendLine($" Setup types offset: {SetupTypesOffset} (0x{SetupTypesOffset:X})");
|
|
builder.AppendLine($" Setup table offset: {SetupTableOffset} (0x{SetupTableOffset:X})");
|
|
builder.AppendLine($" Reserved 7: {BitConverter.ToString(Reserved7).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 8: {BitConverter.ToString(Reserved8).Replace('-', ' ')}");
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print file descriptor offsets information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintFileDescriptorOffsets(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" File Descriptor Offsets:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (FileDescriptorOffsets == null || FileDescriptorOffsets.Length == 0)
|
|
{
|
|
builder.AppendLine(" No file descriptor offsets");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < FileDescriptorOffsets.Length; i++)
|
|
{
|
|
builder.AppendLine($" File Descriptor Offset {i}: {FileDescriptorOffsets[i]} (0x{FileDescriptorOffsets[i]:X})");
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print directory names information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintDirectoryNames(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Directory Names:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (DirectoryNames == null || DirectoryNames.Length == 0)
|
|
{
|
|
builder.AppendLine(" No directory names");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < DirectoryNames.Length; i++)
|
|
{
|
|
builder.AppendLine($" Directory Name {i}: {DirectoryNames[i] ?? "[NULL]"}");
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print file descriptors information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintFileDescriptors(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" File Descriptors:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (FileDescriptors == null || FileDescriptors.Length == 0)
|
|
{
|
|
builder.AppendLine(" No file descriptors");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < FileDescriptors.Length; i++)
|
|
{
|
|
var fileDescriptor = FileDescriptors[i];
|
|
builder.AppendLine($" File Descriptor {i}:");
|
|
builder.AppendLine($" Name offset: {fileDescriptor.NameOffset} (0x{fileDescriptor.NameOffset:X})");
|
|
builder.AppendLine($" Name: {fileDescriptor.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Directory index: {fileDescriptor.DirectoryIndex} (0x{fileDescriptor.DirectoryIndex:X})");
|
|
builder.AppendLine($" Flags: {fileDescriptor.Flags} (0x{fileDescriptor.Flags:X})");
|
|
builder.AppendLine($" Expanded size: {fileDescriptor.ExpandedSize} (0x{fileDescriptor.ExpandedSize:X})");
|
|
builder.AppendLine($" Compressed size: {fileDescriptor.CompressedSize} (0x{fileDescriptor.CompressedSize:X})");
|
|
builder.AppendLine($" Data offset: {fileDescriptor.DataOffset} (0x{fileDescriptor.DataOffset:X})");
|
|
builder.AppendLine($" MD5: {BitConverter.ToString(fileDescriptor.MD5 ?? new byte[0]).Replace('-', ' ')}");
|
|
builder.AppendLine($" Volume: {fileDescriptor.Volume} (0x{fileDescriptor.Volume:X})");
|
|
builder.AppendLine($" Link previous: {fileDescriptor.LinkPrevious} (0x{fileDescriptor.LinkPrevious:X})");
|
|
builder.AppendLine($" Link next: {fileDescriptor.LinkNext} (0x{fileDescriptor.LinkNext:X})");
|
|
builder.AppendLine($" Link flags: {fileDescriptor.LinkFlags} (0x{fileDescriptor.LinkFlags:X})");
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print file group offsets information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintFileGroupOffsets(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" File Group Offsets:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (FileGroupOffsets == null || FileGroupOffsets.Count == 0)
|
|
{
|
|
builder.AppendLine(" No file group offsets");
|
|
}
|
|
else
|
|
{
|
|
foreach (var kvp in FileGroupOffsets)
|
|
{
|
|
long offset = kvp.Key;
|
|
var offsetList = kvp.Value;
|
|
builder.AppendLine($" File Group Offset {offset}:");
|
|
if (offsetList == null)
|
|
{
|
|
builder.AppendLine($" Unassigned file group");
|
|
}
|
|
else
|
|
{
|
|
builder.AppendLine($" Name offset: {offsetList.NameOffset} (0x{offsetList.NameOffset:X})");
|
|
builder.AppendLine($" Name: {offsetList.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Descriptor offset: {offsetList.DescriptorOffset} (0x{offsetList.DescriptorOffset:X})");
|
|
builder.AppendLine($" Next offset: {offsetList.NextOffset} (0x{offsetList.NextOffset:X})");
|
|
}
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print file groups information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintFileGroups(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" File Groups:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (FileGroups == null || FileGroups.Length == 0)
|
|
{
|
|
builder.AppendLine(" No file groups");
|
|
builder.AppendLine();
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < FileGroups.Length; i++)
|
|
{
|
|
var fileGroup = FileGroups[i];
|
|
builder.AppendLine($" File Group {i}:");
|
|
if (fileGroup == null)
|
|
{
|
|
builder.AppendLine($" Unassigned file group");
|
|
}
|
|
else
|
|
{
|
|
builder.AppendLine($" Name offset: {fileGroup.NameOffset} (0x{fileGroup.NameOffset:X})");
|
|
builder.AppendLine($" Name: {fileGroup.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Expanded size: {fileGroup.ExpandedSize} (0x{fileGroup.ExpandedSize:X})");
|
|
builder.AppendLine($" Reserved 0: {BitConverter.ToString(fileGroup.Reserved0).Replace('-', ' ')}");
|
|
builder.AppendLine($" Compressed size: {fileGroup.CompressedSize} (0x{fileGroup.CompressedSize:X})");
|
|
builder.AppendLine($" Reserved 1: {BitConverter.ToString(fileGroup.Reserved1).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 2: {BitConverter.ToString(fileGroup.Reserved2).Replace('-', ' ')}");
|
|
builder.AppendLine($" Attribute 1: {fileGroup.Attribute1} (0x{fileGroup.Attribute1:X})");
|
|
builder.AppendLine($" Attribute 2: {fileGroup.Attribute2} (0x{fileGroup.Attribute2:X})");
|
|
builder.AppendLine($" First file: {fileGroup.FirstFile} (0x{fileGroup.FirstFile:X})");
|
|
builder.AppendLine($" Last file: {fileGroup.LastFile} (0x{fileGroup.LastFile:X})");
|
|
builder.AppendLine($" Unknown offset: {fileGroup.UnknownOffset} (0x{fileGroup.UnknownOffset:X})");
|
|
builder.AppendLine($" Var 4 offset: {fileGroup.Var4Offset} (0x{fileGroup.Var4Offset:X})");
|
|
builder.AppendLine($" Var 1 offset: {fileGroup.Var1Offset} (0x{fileGroup.Var1Offset:X})");
|
|
builder.AppendLine($" HTTP location offset: {fileGroup.HTTPLocationOffset} (0x{fileGroup.HTTPLocationOffset:X})");
|
|
builder.AppendLine($" FTP location offset: {fileGroup.FTPLocationOffset} (0x{fileGroup.FTPLocationOffset:X})");
|
|
builder.AppendLine($" Misc. offset: {fileGroup.MiscOffset} (0x{fileGroup.MiscOffset:X})");
|
|
builder.AppendLine($" Var 2 offset: {fileGroup.Var2Offset} (0x{fileGroup.Var2Offset:X})");
|
|
builder.AppendLine($" Target directory offset: {fileGroup.TargetDirectoryOffset} (0x{fileGroup.TargetDirectoryOffset:X})");
|
|
builder.AppendLine($" Reserved 3: {BitConverter.ToString(fileGroup.Reserved3).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 4: {BitConverter.ToString(fileGroup.Reserved4).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 5: {BitConverter.ToString(fileGroup.Reserved5).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 6: {BitConverter.ToString(fileGroup.Reserved6).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 7: {BitConverter.ToString(fileGroup.Reserved7).Replace('-', ' ')}");
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print component offsets information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintComponentOffsets(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Component Offsets:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (ComponentOffsets == null || ComponentOffsets.Count == 0)
|
|
{
|
|
builder.AppendLine(" No component offsets");
|
|
}
|
|
else
|
|
{
|
|
foreach (var kvp in ComponentOffsets)
|
|
{
|
|
long offset = kvp.Key;
|
|
var offsetList = kvp.Value;
|
|
builder.AppendLine($" Component Offset {offset}:");
|
|
if (offsetList == null)
|
|
{
|
|
builder.AppendLine($" Unassigned component");
|
|
}
|
|
else
|
|
{
|
|
builder.AppendLine($" Name offset: {offsetList.NameOffset} (0x{offsetList.NameOffset:X})");
|
|
builder.AppendLine($" Name: {offsetList.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Descriptor offset: {offsetList.DescriptorOffset} (0x{offsetList.DescriptorOffset:X})");
|
|
builder.AppendLine($" Next offset: {offsetList.NextOffset} (0x{offsetList.NextOffset:X})");
|
|
}
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print components information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintComponents(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Components:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (Components == null || Components.Length == 0)
|
|
{
|
|
builder.AppendLine(" No components");
|
|
builder.AppendLine();
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < Components.Length; i++)
|
|
{
|
|
var component = Components[i];
|
|
builder.AppendLine($" Component {i}:");
|
|
if (component == null)
|
|
{
|
|
builder.AppendLine($" Unassigned component");
|
|
}
|
|
else
|
|
{
|
|
builder.AppendLine($" Identifier offset: {component.IdentifierOffset} (0x{component.IdentifierOffset:X})");
|
|
builder.AppendLine($" Identifier: {component.Identifier ?? "[NULL]"}");
|
|
builder.AppendLine($" Descriptor offset: {component.DescriptorOffset} (0x{component.DescriptorOffset:X})");
|
|
builder.AppendLine($" Display name offset: {component.DisplayNameOffset} (0x{component.DisplayNameOffset:X})");
|
|
builder.AppendLine($" Display name: {component.DisplayName ?? "[NULL]"}");
|
|
builder.AppendLine($" Reserved 0: {BitConverter.ToString(component.Reserved0).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved offset 0: {component.ReservedOffset0} (0x{component.ReservedOffset0:X})");
|
|
builder.AppendLine($" Reserved offset 1: {component.ReservedOffset1} (0x{component.ReservedOffset1:X})");
|
|
builder.AppendLine($" Component index: {component.ComponentIndex} (0x{component.ComponentIndex:X})");
|
|
builder.AppendLine($" Name offset: {component.NameOffset} (0x{component.NameOffset:X})");
|
|
builder.AppendLine($" Name: {component.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Reserved offset 2: {component.ReservedOffset2} (0x{component.ReservedOffset2:X})");
|
|
builder.AppendLine($" Reserved offset 3: {component.ReservedOffset3} (0x{component.ReservedOffset3:X})");
|
|
builder.AppendLine($" Reserved offset 4: {component.ReservedOffset4} (0x{component.ReservedOffset4:X})");
|
|
builder.AppendLine($" Reserved 1: {BitConverter.ToString(component.Reserved1).Replace('-', ' ')}");
|
|
builder.AppendLine($" CLSID offset: {component.CLSIDOffset} (0x{component.CLSIDOffset:X})");
|
|
builder.AppendLine($" CLSID: {component.CLSID}");
|
|
builder.AppendLine($" Reserved 2: {BitConverter.ToString(component.Reserved2).Replace('-', ' ')}");
|
|
builder.AppendLine($" Reserved 3: {BitConverter.ToString(component.Reserved3).Replace('-', ' ')}");
|
|
builder.AppendLine($" Depends count: {component.DependsCount} (0x{component.DependsCount:X})");
|
|
builder.AppendLine($" Depends offset: {component.DependsOffset} (0x{component.DependsOffset:X})");
|
|
builder.AppendLine($" File group count: {component.FileGroupCount} (0x{component.FileGroupCount:X})");
|
|
builder.AppendLine($" File group names offset: {component.FileGroupNamesOffset} (0x{component.FileGroupNamesOffset:X})");
|
|
builder.AppendLine();
|
|
|
|
builder.AppendLine($" File group names:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (component.FileGroupNames == null || component.FileGroupNames.Length == 0)
|
|
{
|
|
builder.AppendLine(" No file group names");
|
|
}
|
|
else
|
|
{
|
|
for (int j = 0; j < component.FileGroupNames.Length; j++)
|
|
{
|
|
builder.AppendLine($" File Group Name {j}: {component.FileGroupNames[j] ?? "[NULL]"}");
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
|
|
builder.AppendLine($" X3 count: {component.X3Count} (0x{component.X3Count:X})");
|
|
builder.AppendLine($" X3 offset: {component.X3Offset} (0x{component.X3Offset:X})");
|
|
builder.AppendLine($" Sub-components count: {component.SubComponentsCount} (0x{component.SubComponentsCount:X})");
|
|
builder.AppendLine($" Sub-components offset: {component.SubComponentsOffset} (0x{component.SubComponentsOffset:X})");
|
|
builder.AppendLine($" Next component offset: {component.NextComponentOffset} (0x{component.NextComponentOffset:X})");
|
|
builder.AppendLine($" Reserved offset 5: {component.ReservedOffset5} (0x{component.ReservedOffset5:X})");
|
|
builder.AppendLine($" Reserved offset 6: {component.ReservedOffset6} (0x{component.ReservedOffset6:X})");
|
|
builder.AppendLine($" Reserved offset 7: {component.ReservedOffset7} (0x{component.ReservedOffset7:X})");
|
|
builder.AppendLine($" Reserved offset 8: {component.ReservedOffset8} (0x{component.ReservedOffset8:X})");
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
#if NET6_0_OR_GREATER
|
|
|
|
/// <inheritdoc/>
|
|
public override string ExportJSON() => System.Text.Json.JsonSerializer.Serialize(_cabinet, _jsonSerializerOptions);
|
|
|
|
#endif
|
|
|
|
#endregion
|
|
}
|
|
}
|