mirror of
https://github.com/SabreTools/BinaryObjectScanner.git
synced 2026-02-13 05:35:24 +00:00
833 lines
34 KiB
C#
833 lines
34 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using ICSharpCode.SharpZipLib.Zip.Compression;
|
|
|
|
namespace BurnOutSharp.Wrappers
|
|
{
|
|
public class SGA : WrapperBase
|
|
{
|
|
#region Descriptive Properties
|
|
|
|
/// <inheritdoc/>
|
|
public override string Description => "SGA";
|
|
|
|
#endregion
|
|
|
|
#region Pass-Through Properties
|
|
|
|
#region Header
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.Signature"/>
|
|
public string Signature => _file.Header.Signature;
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.MajorVersion"/>
|
|
public ushort MajorVersion => _file.Header.MajorVersion;
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.MinorVersion"/>
|
|
public ushort MinorVersion => _file.Header.MinorVersion;
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.FileMD5"/>
|
|
public byte[] FileMD5
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Header as Models.SGA.Header4).FileMD5;
|
|
case 5: return (_file.Header as Models.SGA.Header4).FileMD5;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.Name"/>
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Header as Models.SGA.Header4).Name;
|
|
case 5: return (_file.Header as Models.SGA.Header4).Name;
|
|
case 6: return (_file.Header as Models.SGA.Header6).Name;
|
|
case 7: return (_file.Header as Models.SGA.Header6).Name;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.HeaderMD5"/>
|
|
public byte[] HeaderMD5
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Header as Models.SGA.Header4).HeaderMD5;
|
|
case 5: return (_file.Header as Models.SGA.Header4).HeaderMD5;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.HeaderLength"/>
|
|
public uint? HeaderLength
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Header as Models.SGA.Header4).HeaderLength;
|
|
case 5: return (_file.Header as Models.SGA.Header4).HeaderLength;
|
|
case 6: return (_file.Header as Models.SGA.Header6).HeaderLength;
|
|
case 7: return (_file.Header as Models.SGA.Header6).HeaderLength;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.FileDataOffset"/>
|
|
public uint? FileDataOffset
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Header as Models.SGA.Header4).FileDataOffset;
|
|
case 5: return (_file.Header as Models.SGA.Header4).FileDataOffset;
|
|
case 6: return (_file.Header as Models.SGA.Header6).FileDataOffset;
|
|
case 7: return (_file.Header as Models.SGA.Header6).FileDataOffset;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.Header4.Dummy0"/>
|
|
public uint? Dummy0
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Header as Models.SGA.Header4).Dummy0;
|
|
case 5: return (_file.Header as Models.SGA.Header4).Dummy0;
|
|
case 6: return (_file.Header as Models.SGA.Header6).Dummy0;
|
|
case 7: return (_file.Header as Models.SGA.Header6).Dummy0;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Directory
|
|
|
|
#region Directory Header
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.SectionOffset"/>
|
|
public uint? SectionOffset
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.SectionOffset;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.SectionOffset;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.SectionOffset;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.SectionOffset;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.SectionCount"/>
|
|
public uint? SectionCount
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.SectionCount;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.SectionCount;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.SectionCount;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.SectionCount;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.FolderOffset"/>
|
|
public uint? FolderOffset
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.FolderOffset;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.FolderOffset;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.FolderOffset;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.FolderOffset;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.FolderCount"/>
|
|
public uint? FolderCount
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.FolderCount;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.FolderCount;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.FolderCount;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.FolderCount;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.FileOffset"/>
|
|
public uint? FileOffset
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.FileOffset;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.FileOffset;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.FileOffset;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.FileOffset;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.FileCount"/>
|
|
public uint? FileCount
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.FileCount;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.FileCount;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.FileCount;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.FileCount;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.StringTableOffset"/>
|
|
public uint? StringTableOffset
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.StringTableOffset;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.StringTableOffset;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.StringTableOffset;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.StringTableOffset;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader{T}.StringTableCount"/>
|
|
public uint? StringTableCount
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).DirectoryHeader.StringTableCount;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).DirectoryHeader.StringTableCount;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).DirectoryHeader.StringTableCount;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.StringTableCount;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader7.HashTableOffset"/>
|
|
public uint? HashTableOffset
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.HashTableOffset;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc cref="Models.SGA.DirectoryHeader7.BlockSize"/>
|
|
public uint? BlockSize
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).DirectoryHeader.BlockSize;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Sections
|
|
|
|
/// <inheritdoc cref="Models.SGA.SpecializedDirectory{THeader, TDirectoryHeader, TSection, TFolder, TFile, U}.Sections"/>
|
|
public object[] Sections
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).Sections;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).Sections;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).Sections;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).Sections;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Folders
|
|
|
|
/// <inheritdoc cref="Models.SGA.SpecializedDirectory{THeader, TDirectoryHeader, TSection, TFolder, TFile, U}.Folders"/>
|
|
public object[] Folders
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).Folders;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).Folders;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).Folders;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).Folders;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Files
|
|
|
|
/// <inheritdoc cref="Models.SGA.SpecializedDirectory{THeader, TDirectoryHeader, TSection, TFolder, TFile, U}.Files"/>
|
|
public object[] Files
|
|
{
|
|
get
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: return (_file.Directory as Models.SGA.Directory4).Files;
|
|
case 5: return (_file.Directory as Models.SGA.Directory5).Files;
|
|
case 6: return (_file.Directory as Models.SGA.Directory6).Files;
|
|
case 7: return (_file.Directory as Models.SGA.Directory7).Files;
|
|
default: return null;
|
|
};
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
// TODO: Figure out how to deal with all of the parts of the directory
|
|
// TODO: Should anything be passed through?
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Extension Properties
|
|
|
|
// TODO: Figure out what extension oroperties are needed
|
|
|
|
#endregion
|
|
|
|
#region Instance Variables
|
|
|
|
/// <summary>
|
|
/// Internal representation of the SGA
|
|
/// </summary>
|
|
private Models.SGA.File _file;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
/// <summary>
|
|
/// Private constructor
|
|
/// </summary>
|
|
private SGA() { }
|
|
|
|
/// <summary>
|
|
/// Create an SGA from a byte array and offset
|
|
/// </summary>
|
|
/// <param name="data">Byte array representing the SGA</param>
|
|
/// <param name="offset">Offset within the array to parse</param>
|
|
/// <returns>An SGA wrapper on success, null on failure</returns>
|
|
public static SGA 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 SGA from a Stream
|
|
/// </summary>
|
|
/// <param name="data">Stream representing the SGA</param>
|
|
/// <returns>An SGA wrapper on success, null on failure</returns>
|
|
public static SGA Create(Stream data)
|
|
{
|
|
// If the data is invalid
|
|
if (data == null || data.Length == 0 || !data.CanSeek || !data.CanRead)
|
|
return null;
|
|
|
|
var file = Builders.SGA.ParseFile(data);
|
|
if (file == null)
|
|
return null;
|
|
|
|
var wrapper = new SGA
|
|
{
|
|
_file = file,
|
|
_dataSource = DataSource.Stream,
|
|
_streamData = data,
|
|
};
|
|
return wrapper;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Printing
|
|
|
|
/// <inheritdoc/>
|
|
public override StringBuilder PrettyPrint()
|
|
{
|
|
StringBuilder builder = new StringBuilder();
|
|
|
|
builder.AppendLine("SGA Information:");
|
|
builder.AppendLine("-------------------------");
|
|
builder.AppendLine();
|
|
|
|
// Header
|
|
PrintHeader(builder);
|
|
|
|
// Directory
|
|
PrintDirectoryHeader(builder);
|
|
PrintSections(builder);
|
|
PrintFolders(builder);
|
|
PrintFiles(builder);
|
|
// TODO: Should we print the string table?
|
|
|
|
return builder;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print header information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintHeader(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Header Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
builder.AppendLine($" Signature: {Signature}");
|
|
builder.AppendLine($" Major version: {MajorVersion} (0x{MajorVersion:X})");
|
|
builder.AppendLine($" Minor version: {MinorVersion} (0x{MinorVersion:X})");
|
|
builder.AppendLine($" File MD5: {(FileMD5 == null ? "[NULL]" : BitConverter.ToString(FileMD5).Replace("-", string.Empty))}");
|
|
builder.AppendLine($" Name: {Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Header MD5: {(HeaderMD5 == null ? "[NULL]" : BitConverter.ToString(HeaderMD5).Replace("-", string.Empty))}");
|
|
builder.AppendLine($" Header length: {HeaderLength?.ToString() ?? "[NULL]"} (0x{HeaderLength?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" File data offset: {FileDataOffset?.ToString() ?? "[NULL]"} (0x{FileDataOffset?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" Dummy 0: {Dummy0?.ToString() ?? "[NULL]"} (0x{Dummy0?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print directory header information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintDirectoryHeader(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Directory Header Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
builder.AppendLine($" Section offset: {SectionOffset?.ToString() ?? "[NULL]"} (0x{SectionOffset?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" Section count: {SectionCount?.ToString() ?? "[NULL]"} (0x{SectionCount?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" Folder offset: {FolderOffset?.ToString() ?? "[NULL]"} (0x{FolderOffset?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" Folder count: {FolderCount?.ToString() ?? "[NULL]"} (0x{FolderCount?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" File offset: {FileOffset?.ToString() ?? "[NULL]"} (0x{FileOffset?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" File count: {FileCount?.ToString() ?? "[NULL]"} (0x{FileCount?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" String table offset: {StringTableOffset?.ToString() ?? "[NULL]"} (0x{StringTableOffset?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" String table count: {StringTableCount?.ToString() ?? "[NULL]"} (0x{StringTableCount?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" Hash table offset: {HashTableOffset?.ToString() ?? "[NULL]"} (0x{HashTableOffset?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine($" Block size: {BlockSize?.ToString() ?? "[NULL]"} (0x{BlockSize?.ToString("X") ?? "[NULL]"})");
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print sections information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintSections(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Sections Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (Sections == null || Sections.Length == 0)
|
|
{
|
|
builder.AppendLine(" No sections");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < Sections.Length; i++)
|
|
{
|
|
builder.AppendLine($" Section {i}");
|
|
switch (MajorVersion)
|
|
{
|
|
case 4:
|
|
var section4 = Sections[i] as Models.SGA.Section4;
|
|
builder.AppendLine($" Alias: {section4.Alias ?? "[NULL]"}");
|
|
builder.AppendLine($" Name: {section4.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Folder start index: {section4.FolderStartIndex} (0x{section4.FolderStartIndex:X})");
|
|
builder.AppendLine($" Folder end index: {section4.FolderEndIndex} (0x{section4.FolderEndIndex:X})");
|
|
builder.AppendLine($" File start index: {section4.FileStartIndex} (0x{section4.FileStartIndex:X})");
|
|
builder.AppendLine($" File end index: {section4.FileEndIndex} (0x{section4.FileEndIndex:X})");
|
|
builder.AppendLine($" Folder root index: {section4.FolderRootIndex} (0x{section4.FolderRootIndex:X})");
|
|
break;
|
|
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
var section5 = Sections[i] as Models.SGA.Section5;
|
|
builder.AppendLine($" Alias: {section5.Alias ?? "[NULL]"}");
|
|
builder.AppendLine($" Name: {section5.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Folder start index: {section5.FolderStartIndex} (0x{section5.FolderStartIndex:X})");
|
|
builder.AppendLine($" Folder end index: {section5.FolderEndIndex} (0x{section5.FolderEndIndex:X})");
|
|
builder.AppendLine($" File start index: {section5.FileStartIndex} (0x{section5.FileStartIndex:X})");
|
|
builder.AppendLine($" File end index: {section5.FileEndIndex} (0x{section5.FileEndIndex:X})");
|
|
builder.AppendLine($" Folder root index: {section5.FolderRootIndex} (0x{section5.FolderRootIndex:X})");
|
|
break;
|
|
default:
|
|
builder.AppendLine($" Unknown format for version {MajorVersion}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print folders information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintFolders(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Folders Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (Folders == null || Folders.Length == 0)
|
|
{
|
|
builder.AppendLine(" No folders");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < Folders.Length; i++)
|
|
{
|
|
builder.AppendLine($" Folder {i}");
|
|
switch (MajorVersion)
|
|
{
|
|
case 4:
|
|
var folder4 = Folders[i] as Models.SGA.Folder4;
|
|
builder.AppendLine($" Name offset: {folder4.NameOffset} (0x{folder4.NameOffset:X})");
|
|
builder.AppendLine($" Name: {folder4.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Folder start index: {folder4.FolderStartIndex} (0x{folder4.FolderStartIndex:X})");
|
|
builder.AppendLine($" Folder end index: {folder4.FolderEndIndex} (0x{folder4.FolderEndIndex:X})");
|
|
builder.AppendLine($" File start index: {folder4.FileStartIndex} (0x{folder4.FileStartIndex:X})");
|
|
builder.AppendLine($" File end index: {folder4.FileEndIndex} (0x{folder4.FileEndIndex:X})");
|
|
break;
|
|
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
var folder5 = Folders[i] as Models.SGA.Folder5;
|
|
builder.AppendLine($" Name offset: {folder5.NameOffset} (0x{folder5.NameOffset:X})");
|
|
builder.AppendLine($" Name: {folder5.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Folder start index: {folder5.FolderStartIndex} (0x{folder5.FolderStartIndex:X})");
|
|
builder.AppendLine($" Folder end index: {folder5.FolderEndIndex} (0x{folder5.FolderEndIndex:X})");
|
|
builder.AppendLine($" File start index: {folder5.FileStartIndex} (0x{folder5.FileStartIndex:X})");
|
|
builder.AppendLine($" File end index: {folder5.FileEndIndex} (0x{folder5.FileEndIndex:X})");
|
|
break;
|
|
default:
|
|
builder.AppendLine($" Unknown format for version {MajorVersion}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Print files information
|
|
/// </summary>
|
|
/// <param name="builder">StringBuilder to append information to</param>
|
|
private void PrintFiles(StringBuilder builder)
|
|
{
|
|
builder.AppendLine(" Files Information:");
|
|
builder.AppendLine(" -------------------------");
|
|
if (Files == null || Files.Length == 0)
|
|
{
|
|
builder.AppendLine(" No files");
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < Files.Length; i++)
|
|
{
|
|
builder.AppendLine($" File {i}");
|
|
switch (MajorVersion)
|
|
{
|
|
case 4:
|
|
case 5:
|
|
var file4 = Files[i] as Models.SGA.File4;
|
|
builder.AppendLine($" Name offset: {file4.NameOffset} (0x{file4.NameOffset:X})");
|
|
builder.AppendLine($" Name: {file4.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Offset: {file4.Offset} (0x{file4.Offset:X})");
|
|
builder.AppendLine($" Size on disk: {file4.SizeOnDisk} (0x{file4.SizeOnDisk:X})");
|
|
builder.AppendLine($" Size: {file4.Size} (0x{file4.Size:X})");
|
|
builder.AppendLine($" Time modified: {file4.TimeModified} (0x{file4.TimeModified:X})");
|
|
builder.AppendLine($" Dummy 0: {file4.Dummy0} (0x{file4.Dummy0:X})");
|
|
builder.AppendLine($" Type: {file4.Type} (0x{file4.Type:X})");
|
|
break;
|
|
|
|
case 6:
|
|
var file6 = Files[i] as Models.SGA.File6;
|
|
builder.AppendLine($" Name offset: {file6.NameOffset} (0x{file6.NameOffset:X})");
|
|
builder.AppendLine($" Name: {file6.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Offset: {file6.Offset} (0x{file6.Offset:X})");
|
|
builder.AppendLine($" Size on disk: {file6.SizeOnDisk} (0x{file6.SizeOnDisk:X})");
|
|
builder.AppendLine($" Size: {file6.Size} (0x{file6.Size:X})");
|
|
builder.AppendLine($" Time modified: {file6.TimeModified} (0x{file6.TimeModified:X})");
|
|
builder.AppendLine($" Dummy 0: {file6.Dummy0} (0x{file6.Dummy0:X})");
|
|
builder.AppendLine($" Type: {file6.Type} (0x{file6.Type:X})");
|
|
builder.AppendLine($" CRC32: {file6.CRC32} (0x{file6.CRC32:X})");
|
|
break;
|
|
case 7:
|
|
var file7 = Files[i] as Models.SGA.File7;
|
|
builder.AppendLine($" Name offset: {file7.NameOffset} (0x{file7.NameOffset:X})");
|
|
builder.AppendLine($" Name: {file7.Name ?? "[NULL]"}");
|
|
builder.AppendLine($" Offset: {file7.Offset} (0x{file7.Offset:X})");
|
|
builder.AppendLine($" Size on disk: {file7.SizeOnDisk} (0x{file7.SizeOnDisk:X})");
|
|
builder.AppendLine($" Size: {file7.Size} (0x{file7.Size:X})");
|
|
builder.AppendLine($" Time modified: {file7.TimeModified} (0x{file7.TimeModified:X})");
|
|
builder.AppendLine($" Dummy 0: {file7.Dummy0} (0x{file7.Dummy0:X})");
|
|
builder.AppendLine($" Type: {file7.Type} (0x{file7.Type:X})");
|
|
builder.AppendLine($" CRC32: {file7.CRC32} (0x{file7.CRC32:X})");
|
|
builder.AppendLine($" Hash offset: {file7.HashOffset} (0x{file7.HashOffset:X})");
|
|
break;
|
|
default:
|
|
builder.AppendLine($" Unknown format for version {MajorVersion}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
builder.AppendLine();
|
|
}
|
|
|
|
#if NET6_0_OR_GREATER
|
|
|
|
/// <inheritdoc/>
|
|
public override string ExportJSON() => System.Text.Json.JsonSerializer.Serialize(_file, _jsonSerializerOptions);
|
|
|
|
#endif
|
|
|
|
#endregion
|
|
|
|
#region Extraction
|
|
|
|
/// <summary>
|
|
/// Extract all files from the SGA to an output directory
|
|
/// </summary>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <returns>True if all files extracted, false otherwise</returns>
|
|
public bool ExtractAll(string outputDirectory)
|
|
{
|
|
// If we have no files
|
|
if (Files == null || Files.Length == 0)
|
|
return false;
|
|
|
|
// Loop through and extract all files to the output
|
|
bool allExtracted = true;
|
|
for (int i = 0; i < Files.Length; i++)
|
|
{
|
|
allExtracted &= ExtractFile(i, outputDirectory);
|
|
}
|
|
|
|
return allExtracted;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Extract a file from the SGA to an output directory by index
|
|
/// </summary>
|
|
/// <param name="index">File index to extract</param>
|
|
/// <param name="outputDirectory">Output directory to write to</param>
|
|
/// <returns>True if the file extracted, false otherwise</returns>
|
|
public bool ExtractFile(int index, string outputDirectory)
|
|
{
|
|
// If we have no files
|
|
if (Files == null || Files.Length == 0)
|
|
return false;
|
|
|
|
// If the files index is invalid
|
|
if (index < 0 || index >= Files.Length)
|
|
return false;
|
|
|
|
// Get the files
|
|
var file = Files[index];
|
|
if (file == null)
|
|
return false;
|
|
|
|
// Create the filename
|
|
string filename;
|
|
switch (MajorVersion)
|
|
{
|
|
case 4:
|
|
case 5: filename = (file as Models.SGA.File4).Name; break;
|
|
case 6: filename = (file as Models.SGA.File6).Name; break;
|
|
case 7: filename = (file as Models.SGA.File7).Name; break;
|
|
default: return false;
|
|
}
|
|
|
|
// Loop through and get all parent directories
|
|
var parentNames = new List<string> { filename };
|
|
|
|
// Get the parent directory
|
|
object folder;
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: folder = (Folders as Models.SGA.Folder4[]).FirstOrDefault(f => index >= f.FileStartIndex && index <= f.FileEndIndex); break;
|
|
case 5:
|
|
case 6:
|
|
case 7: folder = (Folders as Models.SGA.Folder5[]).FirstOrDefault(f => index >= f.FileStartIndex && index <= f.FileEndIndex); break;
|
|
default: return false;
|
|
}
|
|
|
|
// If we have a parent folder
|
|
if (folder != null)
|
|
{
|
|
switch (MajorVersion)
|
|
{
|
|
case 4: parentNames.Add((folder as Models.SGA.Folder4).Name); break;
|
|
case 5:
|
|
case 6:
|
|
case 7: parentNames.Add((folder as Models.SGA.Folder5).Name); break;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
// TODO: Should the section name/alias be used in the path as well?
|
|
|
|
// Reverse and assemble the filename
|
|
parentNames.Reverse();
|
|
filename = Path.Combine(parentNames.ToArray());
|
|
|
|
// Get the file offset
|
|
long fileOffset;
|
|
switch (MajorVersion)
|
|
{
|
|
case 4:
|
|
case 5: fileOffset = (file as Models.SGA.File4).Offset; break;
|
|
case 6: fileOffset = (file as Models.SGA.File6).Offset; break;
|
|
case 7: fileOffset = (file as Models.SGA.File7).Offset; break;
|
|
default: return false;
|
|
}
|
|
|
|
// Adjust the file offset
|
|
fileOffset += FileDataOffset.Value;
|
|
|
|
// Get the file sizes
|
|
long fileSize, outputFileSize;
|
|
switch (MajorVersion)
|
|
{
|
|
case 4:
|
|
case 5:
|
|
fileSize = (file as Models.SGA.File4).SizeOnDisk;
|
|
outputFileSize = (file as Models.SGA.File4).Size;
|
|
break;
|
|
case 6:
|
|
fileSize = (file as Models.SGA.File6).SizeOnDisk;
|
|
outputFileSize = (file as Models.SGA.File6).Size;
|
|
break;
|
|
case 7:
|
|
fileSize = (file as Models.SGA.File7).SizeOnDisk;
|
|
outputFileSize = (file as Models.SGA.File7).Size;
|
|
break;
|
|
default: return false;
|
|
}
|
|
|
|
// Read the compressed data directly
|
|
byte[] compressedData = ReadFromDataSource((int)fileOffset, (int)fileSize);
|
|
if (compressedData == null)
|
|
return false;
|
|
|
|
// If the compressed and uncompressed sizes match
|
|
byte[] data;
|
|
if (fileSize == outputFileSize)
|
|
{
|
|
data = compressedData;
|
|
}
|
|
else
|
|
{
|
|
// Decompress the data
|
|
data = new byte[outputFileSize];
|
|
Inflater inflater = new Inflater();
|
|
inflater.SetInput(compressedData);
|
|
inflater.Inflate(data);
|
|
}
|
|
|
|
// If we have an invalid output directory
|
|
if (string.IsNullOrWhiteSpace(outputDirectory))
|
|
return false;
|
|
|
|
// Create the full output path
|
|
filename = Path.Combine(outputDirectory, filename);
|
|
|
|
// Ensure the output directory is created
|
|
Directory.CreateDirectory(Path.GetDirectoryName(filename));
|
|
|
|
// Try to write the data
|
|
try
|
|
{
|
|
// Open the output file for writing
|
|
using (Stream fs = File.OpenWrite(filename))
|
|
{
|
|
fs.Write(data, 0, data.Length);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |