SabreTools/SabreTools.Serialization
1
0
Fork 0
mirror of https://github.com/SabreTools/SabreTools.Serialization.git synced 2026-07-08 18:06:41 +00:00
Code Issues 56 Packages Projects Releases 20 Wiki Activity

Editorconfig cleanup, use extensions

Browse Source
This commit is contained in:
Matt Nadareski
2026-04-19 09:33:55 -04:00
parent e383771fb6
commit 2462305e0b
27 changed files with 174 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
SabreTools.Data.Models/XRD/File.cs
View File

@@ -237,7 +237,7 @@ namespace SabreTools.Data.Models.XRD
public int DirectoryCount { get; set; }
/// <summary>
/// List of XISO descriptors and their sector offsets and sizes
/// List of XISO descriptors and their sector offsets and sizes
/// The root directory descriptor is not guaranteed to be the first
/// </summary>
public DirectoryEntry[] DirectoryInfo { get; set; } = [];

3
SabreTools.Serialization.Readers/XRD.cs
View File

@@ -1,4 +1,3 @@
using System.Collections.Generic;
using System.IO;
using SabreTools.Data.Models.XRD;
using SabreTools.IO.Extensions;
@@ -105,7 +104,7 @@ namespace SabreTools.Serialization.Readers
var vd = XDVDFS.ParseVolumeDescriptor(data);
if (vd is null)
return null;
xrd.VolumeDescriptor = vd;
xrd.LayoutDescriptor = XDVDFS.ParseLayoutDescriptor(data);

2
SabreTools.Serialization.Writers/Atari7800Cart.cs
View File

@@ -151,7 +151,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write ROM data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}

2
SabreTools.Serialization.Writers/AtariLynxCart.cs
View File

@@ -109,7 +109,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write ROM data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}

2
SabreTools.Serialization.Writers/FDS.cs
View File

@@ -89,7 +89,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write ROM data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}

70
SabreTools.Serialization.Writers/IRD.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using System.Text;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Serialization.Writers
{
@@ -9,6 +10,8 @@ namespace SabreTools.Serialization.Writers
/// <inheritdoc/>
public override Stream? SerializeStream(Data.Models.IRD.File? obj)
{
#region Validation
// If the data is invalid
if (obj?.Magic is null)
return null;
@@ -50,79 +53,68 @@ namespace SabreTools.Serialization.Writers
if (obj.Data2Key.Length != 16)
return null;
#endregion
// Create the output stream
var stream = new MemoryStream();
stream.Write(obj.Magic, 0, obj.Magic.Length);
stream.WriteByte(obj.Version);
stream.Write(obj.Magic);
stream.Write(obj.Version);
byte[] titleId = Encoding.ASCII.GetBytes(obj.TitleID);
stream.Write(titleId, 0, titleId.Length);
stream.Write(titleId);
stream.WriteByte(obj.TitleLength);
stream.Write(obj.TitleLength);
byte[] title = Encoding.ASCII.GetBytes(obj.Title);
stream.Write(title, 0, title.Length);
stream.Write(title);
byte[] systemVersion = Encoding.ASCII.GetBytes(obj.SystemVersion);
stream.Write(systemVersion, 0, systemVersion.Length);
stream.Write(systemVersion);
byte[] gameVersion = Encoding.ASCII.GetBytes(obj.GameVersion);
stream.Write(gameVersion, 0, gameVersion.Length);
stream.Write(gameVersion);
byte[] appVersion = Encoding.ASCII.GetBytes(obj.AppVersion);
stream.Write(appVersion, 0, appVersion.Length);
stream.Write(appVersion);
if (obj.Version == 7)
{
byte[] uid = BitConverter.GetBytes(obj.UID);
stream.Write(uid, 0, uid.Length);
}
stream.WriteLittleEndian(obj.UID);
byte[] headerLength = BitConverter.GetBytes(obj.HeaderLength);
stream.Write(headerLength, 0, headerLength.Length);
stream.Write(obj.Header, 0, obj.Header.Length);
stream.WriteLittleEndian(obj.HeaderLength);
stream.Write(obj.Header);
byte[] footerLength = BitConverter.GetBytes(obj.FooterLength);
stream.Write(footerLength, 0, footerLength.Length);
stream.Write(obj.Footer, 0, obj.Footer.Length);
stream.WriteLittleEndian(obj.FooterLength);
stream.Write(obj.Footer);
stream.WriteByte(obj.RegionCount);
stream.Write(obj.RegionCount);
for (int i = 0; i < obj.RegionCount; i++)
{
stream.Write(obj.RegionHashes[i], 0, obj.RegionHashes[i].Length);
stream.Write(obj.RegionHashes[i]);
}
byte[] fileCount = BitConverter.GetBytes(obj.FileCount);
stream.Write(fileCount, 0, fileCount.Length);
stream.WriteLittleEndian(obj.FileCount);
for (int i = 0; i < obj.FileCount; i++)
{
byte[] fileKey = BitConverter.GetBytes(obj.FileKeys[i]);
stream.Write(fileKey, 0, fileKey.Length);
stream.Write(obj.FileHashes[i], 0, obj.FileHashes[i].Length);
stream.WriteLittleEndian(obj.FileKeys[i]);
stream.Write(obj.FileHashes[i]);
}
byte[] extraConfig = BitConverter.GetBytes(obj.ExtraConfig);
stream.Write(extraConfig, 0, extraConfig.Length);
byte[] attachments = BitConverter.GetBytes(obj.Attachments);
stream.Write(attachments, 0, attachments.Length);
stream.WriteLittleEndian(obj.ExtraConfig);
stream.WriteLittleEndian(obj.Attachments);
if (obj.Version >= 9)
stream.Write(obj.PIC, 0, obj.PIC.Length);
stream.Write(obj.PIC);
stream.Write(obj.Data1Key, 0, obj.Data1Key.Length);
stream.Write(obj.Data2Key, 0, obj.Data2Key.Length);
stream.Write(obj.Data1Key);
stream.Write(obj.Data2Key);
if (obj.Version < 9)
stream.Write(obj.PIC, 0, obj.PIC.Length);
stream.Write(obj.PIC);
if (obj.Version > 7)
{
byte[] uid = BitConverter.GetBytes(obj.UID);
stream.Write(uid, 0, uid.Length);
}
stream.WriteLittleEndian(obj.UID);
byte[] crc = BitConverter.GetBytes(obj.CRC);
stream.Write(crc, 0, crc.Length);
stream.WriteLittleEndian(obj.CRC);
return stream;
}

8
SabreTools.Serialization.Writers/NESCart.cs
View File

@@ -63,7 +63,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write CHR-ROM data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}
@@ -250,7 +250,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write INST-ROM data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}
@@ -279,7 +279,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write PRG-ROM data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}
@@ -308,7 +308,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write trainer data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}

3
SabreTools.Serialization.Writers/QD.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using SabreTools.IO.Extensions;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Serialization.Writers
{
@@ -43,7 +44,7 @@ namespace SabreTools.Serialization.Writers
{
if (Debug) Console.WriteLine("Attempting to write ROM data");
stream.Write(obj, 0, obj.Length);
stream.Write(obj);
stream.Flush();
return true;
}

26
SabreTools.Serialization.Writers/XDVDFS.cs
View File

@@ -23,7 +23,7 @@ namespace SabreTools.Serialization.Writers
// Create the file stream
using var fs = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(obj.ReservedArea, 0, obj.ReservedArea.Length);
fs.Write(obj.ReservedArea);
SerializeVolumeDescriptor(fs, obj.VolumeDescriptor);
if (obj.LayoutDescriptor is not null)
SerializeLayoutDescriptor(fs, obj.LayoutDescriptor);
@@ -79,26 +79,26 @@ namespace SabreTools.Serialization.Writers
public static void SerializeVolumeDescriptor(Stream stream, VolumeDescriptor obj)
{
stream.Write(obj.StartSignature, 0, obj.StartSignature.Length);
stream.Write(obj.StartSignature);
stream.WriteLittleEndian(obj.RootOffset);
stream.WriteLittleEndian(obj.RootSize);
stream.WriteLittleEndian(obj.MasteringTimestamp);
stream.WriteByte(obj.UnknownByte);
stream.Write(obj.Reserved, 0, obj.Reserved.Length);
stream.Write(obj.EndSignature, 0, obj.EndSignature.Length);
stream.Write(obj.UnknownByte);
stream.Write(obj.Reserved);
stream.Write(obj.EndSignature);
}
public static void SerializeLayoutDescriptor(Stream stream, LayoutDescriptor obj)
{
stream.Write(obj.Signature, 0, obj.Signature.Length);
stream.Write(obj.Unused8Bytes, 0, obj.Unused8Bytes.Length);
stream.Write(obj.Signature);
stream.Write(obj.Unused8Bytes);
SerializeFourPartVersionType(stream, obj.XBLayoutVersion);
SerializeFourPartVersionType(stream, obj.XBPremasterVersion);
SerializeFourPartVersionType(stream, obj.XBGameDiscVersion);
SerializeFourPartVersionType(stream, obj.XBOther1Version);
SerializeFourPartVersionType(stream, obj.XBOther2Version);
SerializeFourPartVersionType(stream, obj.XBOther3Version);
stream.Write(obj.Reserved, 0, obj.Reserved.Length);
stream.Write(obj.Reserved);
}
public static void SerializeFourPartVersionType(Stream stream, FourPartVersionType obj)
@@ -114,7 +114,7 @@ namespace SabreTools.Serialization.Writers
foreach (var dr in obj.DirectoryRecords)
SerializeDirectoryRecord(stream, dr);
if (obj.Padding is not null && obj.Padding.Length > 0)
stream.Write(obj.Padding, 0, obj.Padding.Length);
stream.Write(obj.Padding);
}
public static void SerializeDirectoryRecord(Stream stream, DirectoryRecord obj)
@@ -123,11 +123,11 @@ namespace SabreTools.Serialization.Writers
stream.WriteLittleEndian(obj.RightChildOffset);
stream.WriteLittleEndian(obj.ExtentOffset);
stream.WriteLittleEndian(obj.ExtentSize);
stream.WriteByte((byte)obj.FileFlags);
stream.WriteByte(obj.FilenameLength);
stream.Write(obj.Filename, 0, obj.Filename.Length);
stream.Write((byte)obj.FileFlags);
stream.Write(obj.FilenameLength);
stream.Write(obj.Filename);
if (obj.Padding is not null && obj.Padding.Length > 0)
stream.Write(obj.Padding, 0, obj.Padding.Length);
stream.Write(obj.Padding);
}
}
}

201
SabreTools.Serialization.Writers/XRD.cs
View File

@@ -1,6 +1,5 @@
using System;
using System.IO;
using System.Text;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Serialization.Writers
{
@@ -9,6 +8,8 @@ namespace SabreTools.Serialization.Writers
/// <inheritdoc/>
public override Stream? SerializeStream(Data.Models.XRD.File? obj)
{
#region Validation
// If the data is invalid
if (obj?.Magic is null)
return null;
@@ -38,11 +39,11 @@ namespace SabreTools.Serialization.Writers
// If the XGD Type specific fields are not set/unset
if ((obj.XGDType == 1 || obj.XGDType == 2 || obj.XGDType == 3) && obj.SecuritySectors is null)
return null;
if ((obj.XGDType != 1 && obj.XGDType != 2 && obj.XGDType != 3) && obj.SecuritySectors is not null)
if (obj.XGDType != 1 && obj.XGDType != 2 && obj.XGDType != 3 && obj.SecuritySectors is not null)
return null;
if ((obj.XGDType == 2 || obj.XGDType == 3) && obj.Xbox360Certificate is null)
return null;
if ((obj.XGDType != 2 && obj.XGDType != 3) && obj.Xbox360Certificate is not null)
if (obj.XGDType != 2 && obj.XGDType != 3 && obj.Xbox360Certificate is not null)
return null;
// If any static-length fields aren't the correct length
@@ -109,12 +110,14 @@ namespace SabreTools.Serialization.Writers
if (obj.XboxCertificate.AlternateSignatureKeys[i].Length != 16)
return null;
}
if (obj.XboxCertificate.CodeEncKey.Length != 16)
return null;
}
if (obj.Xbox360Certificate is not null)
{
var certificateLength = 388 + 24 * obj.Xbox360Certificate.Table.Length;
var certificateLength = 388 + (24 * obj.Xbox360Certificate.Table.Length);
if (obj.Xbox360Certificate.Length != certificateLength)
return null;
if (obj.Xbox360Certificate.Signature.Length != 256)
@@ -135,6 +138,7 @@ namespace SabreTools.Serialization.Writers
return null;
}
}
if (obj.FileCount != obj.FileInfo.Length)
return null;
for (int i = 0; i < obj.FileInfo.Length; i++)
@@ -142,6 +146,7 @@ namespace SabreTools.Serialization.Writers
if (obj.FileInfo[i].SHA1.Length != 20)
return null;
}
if (obj.DirectoryCount != obj.DirectoryInfo.Length)
return null;
if (obj.VideoISOFileCount is not null && obj.VideoISOFileInfo is not null && obj.VideoISOFileCount != obj.VideoISOFileInfo.Length)
@@ -149,63 +154,56 @@ namespace SabreTools.Serialization.Writers
if (obj.XRDSHA1.Length != 20)
return null;
#endregion
// Create the output stream
var stream = new MemoryStream();
stream.Write(obj.Magic, 0, obj.Magic.Length);
stream.WriteByte(obj.Version);
stream.WriteByte(obj.XGDType);
stream.WriteByte(obj.XGDSubtype);
stream.Write(obj.Ringcode, 0, obj.Ringcode.Length);
stream.Write(obj.Magic);
stream.Write(obj.Version);
stream.Write(obj.XGDType);
stream.Write(obj.XGDSubtype);
stream.Write(obj.Ringcode);
byte[] redumpSize = BitConverter.GetBytes(obj.RedumpSize);
stream.Write(redumpSize, 0, redumpSize.Length);
stream.Write(obj.RedumpCRC, 0, obj.RedumpCRC.Length);
stream.Write(obj.RedumpMD5, 0, obj.RedumpMD5.Length);
stream.Write(obj.RedumpSHA1, 0, obj.RedumpSHA1.Length);
stream.WriteLittleEndian(obj.RedumpSize);
stream.Write(obj.RedumpCRC);
stream.Write(obj.RedumpMD5);
stream.Write(obj.RedumpSHA1);
byte[] rawXISOSize = BitConverter.GetBytes(obj.RawXISOSize);
stream.Write(rawXISOSize, 0, rawXISOSize.Length);
stream.Write(obj.RawXISOCRC, 0, obj.RawXISOCRC.Length);
stream.Write(obj.RawXISOMD5, 0, obj.RawXISOMD5.Length);
stream.Write(obj.RawXISOSHA1, 0, obj.RawXISOSHA1.Length);
stream.WriteLittleEndian(obj.RawXISOSize);
stream.Write(obj.RawXISOCRC);
stream.Write(obj.RawXISOMD5);
stream.Write(obj.RawXISOSHA1);
byte[] cookedXISOSize = BitConverter.GetBytes(obj.CookedXISOSize);
stream.Write(cookedXISOSize, 0, cookedXISOSize.Length);
stream.Write(obj.CookedXISOCRC, 0, obj.CookedXISOCRC.Length);
stream.Write(obj.CookedXISOMD5, 0, obj.CookedXISOMD5.Length);
stream.Write(obj.CookedXISOSHA1, 0, obj.CookedXISOSHA1.Length);
stream.WriteLittleEndian(obj.CookedXISOSize);
stream.Write(obj.CookedXISOCRC);
stream.Write(obj.CookedXISOMD5);
stream.Write(obj.CookedXISOSHA1);
byte[] videoISOSize = BitConverter.GetBytes(obj.VideoISOSize);
stream.Write(videoISOSize, 0, videoISOSize.Length);
stream.Write(obj.VideoISOCRC, 0, obj.VideoISOCRC.Length);
stream.Write(obj.VideoISOMD5, 0, obj.VideoISOMD5.Length);
stream.Write(obj.VideoISOSHA1, 0, obj.VideoISOSHA1.Length);
stream.WriteLittleEndian(obj.VideoISOSize);
stream.Write(obj.VideoISOCRC);
stream.Write(obj.VideoISOMD5);
stream.Write(obj.VideoISOSHA1);
if (obj.WipedVideoISOSize is not null)
{
byte[] wipedVideoISOSize = BitConverter.GetBytes(obj.WipedVideoISOSize ?? 0);
stream.Write(videoISOSize, 0, videoISOSize.Length);
}
stream.WriteLittleEndian(obj.WipedVideoISOSize.Value);
if (obj.WipedVideoISOCRC is not null)
stream.Write(obj.WipedVideoISOCRC, 0, obj.WipedVideoISOCRC.Length);
stream.Write(obj.WipedVideoISOCRC);
if (obj.WipedVideoISOMD5 is not null)
stream.Write(obj.WipedVideoISOMD5, 0, obj.WipedVideoISOMD5.Length);
stream.Write(obj.WipedVideoISOMD5);
if (obj.WipedVideoISOSHA1 is not null)
stream.Write(obj.WipedVideoISOSHA1, 0, obj.WipedVideoISOSHA1.Length);
stream.Write(obj.WipedVideoISOSHA1);
byte[] fillerSize = BitConverter.GetBytes(obj.FillerSize);
stream.Write(fillerSize, 0, fillerSize.Length);
stream.Write(obj.FillerCRC, 0, obj.FillerCRC.Length);
stream.Write(obj.FillerMD5, 0, obj.FillerMD5.Length);
stream.Write(obj.FillerSHA1, 0, obj.FillerSHA1.Length);
stream.WriteLittleEndian(obj.FillerSize);
stream.Write(obj.FillerCRC);
stream.Write(obj.FillerMD5);
stream.Write(obj.FillerSHA1);
if (obj.SecuritySectors is not null)
{
for (int i = 0; i < obj.SecuritySectors.Length; i++)
{
byte[] securitySector = BitConverter.GetBytes(obj.SecuritySectors[i]);
stream.Write(securitySector, 0, securitySector.Length);
stream.Write(obj.SecuritySectors[i]);
}
}
@@ -214,29 +212,23 @@ namespace SabreTools.Serialization.Writers
if (obj.Xbox360Certificate is not null)
SerializeXbox360Certificate(stream, obj.Xbox360Certificate);
byte[] fileCount = BitConverter.GetBytes(obj.FileCount);
stream.Write(fileCount, 0, fileCount.Length);
stream.WriteLittleEndian(obj.FileCount);
for (int i = 0; i < obj.FileInfo.Length; i++)
{
byte[] offset = BitConverter.GetBytes(obj.FileInfo[i].Offset);
stream.Write(offset, 0, offset.Length);
byte[] size = BitConverter.GetBytes(obj.FileInfo[i].Size);
stream.Write(size, 0, size.Length);
stream.Write(obj.FileInfo[i].SHA1, 0, obj.FileInfo[i].SHA1.Length);
stream.WriteLittleEndian(obj.FileInfo[i].Offset);
stream.WriteLittleEndian(obj.FileInfo[i].Size);
stream.Write(obj.FileInfo[i].SHA1);
}
XDVDFS.SerializeVolumeDescriptor(stream, obj.VolumeDescriptor);
if (obj.LayoutDescriptor is not null)
XDVDFS.SerializeLayoutDescriptor(stream, obj.LayoutDescriptor);
byte[] directoryCount = BitConverter.GetBytes(obj.DirectoryCount);
stream.Write(directoryCount, 0, directoryCount.Length);
stream.WriteLittleEndian(obj.DirectoryCount);
for (int i = 0; i < obj.DirectoryInfo.Length; i++)
{
byte[] offset = BitConverter.GetBytes(obj.DirectoryInfo[i].Offset);
stream.Write(offset, 0, offset.Length);
byte[] size = BitConverter.GetBytes(obj.DirectoryInfo[i].Size);
stream.Write(size, 0, size.Length);
stream.Write(obj.DirectoryInfo[i].Offset);
stream.Write(obj.DirectoryInfo[i].Size);
XDVDFS.SerializeDirectoryDescriptor(stream, obj.DirectoryInfo[i].DirectoryDescriptor);
}
@@ -245,77 +237,56 @@ namespace SabreTools.Serialization.Writers
public static void SerializeXboxCertificate(Stream stream, Data.Models.XboxExecutable.Certificate obj)
{
byte[] sizeOfCertificate = BitConverter.GetBytes(obj.SizeOfCertificate);
stream.Write(sizeOfCertificate, 0, sizeOfCertificate.Length);
byte[] timeDate = BitConverter.GetBytes(obj.TimeDate);
stream.Write(timeDate, 0, timeDate.Length);
byte[] titleID = BitConverter.GetBytes(obj.TitleID);
stream.Write(titleID, 0, titleID.Length);
stream.Write(obj.TitleName, 0, obj.TitleName.Length);
stream.WriteLittleEndian(obj.SizeOfCertificate);
stream.WriteLittleEndian(obj.TimeDate);
stream.WriteLittleEndian(obj.TitleID);
stream.Write(obj.TitleName);
for (int i = 0; i < obj.AlternativeTitleIDs.Length; i++)
{
byte[] alternativeTitleID = BitConverter.GetBytes(obj.AlternativeTitleIDs[i]);
stream.Write(alternativeTitleID, 0, alternativeTitleID.Length);
stream.WriteLittleEndian(obj.AlternativeTitleIDs[i]);
}
byte[] allowedMediaTypes = BitConverter.GetBytes((uint)obj.AllowedMediaTypes);
stream.Write(allowedMediaTypes, 0, allowedMediaTypes.Length);
byte[] gameRegion = BitConverter.GetBytes((uint)obj.GameRegion);
stream.Write(gameRegion, 0, gameRegion.Length);
byte[] gameRatings = BitConverter.GetBytes(obj.GameRatings);
stream.Write(gameRatings, 0, gameRatings.Length);
byte[] diskNumber = BitConverter.GetBytes(obj.DiskNumber);
stream.Write(diskNumber, 0, diskNumber.Length);
byte[] version = BitConverter.GetBytes(obj.Version);
stream.Write(version, 0, version.Length);
stream.Write(obj.LANKey, 0, obj.LANKey.Length);
stream.Write(obj.SignatureKey, 0, obj.SignatureKey.Length);
stream.WriteLittleEndian((uint)obj.AllowedMediaTypes);
stream.WriteLittleEndian((uint)obj.GameRegion);
stream.WriteLittleEndian(obj.GameRatings);
stream.WriteLittleEndian(obj.DiskNumber);
stream.WriteLittleEndian(obj.Version);
stream.Write(obj.LANKey);
stream.Write(obj.SignatureKey);
for (int i = 0; i < obj.AlternateSignatureKeys.Length; i++)
{
stream.Write(obj.AlternateSignatureKeys[i], 0, obj.AlternateSignatureKeys[i].Length);
stream.Write(obj.AlternateSignatureKeys[i]);
}
byte[] originalCertificateSize = BitConverter.GetBytes(obj.OriginalCertificateSize);
stream.Write(originalCertificateSize, 0, originalCertificateSize.Length);
byte[] onlineService = BitConverter.GetBytes(obj.OnlineService);
stream.Write(onlineService, 0, onlineService.Length);
byte[] securityFlags = BitConverter.GetBytes(obj.SecurityFlags);
stream.Write(securityFlags, 0, securityFlags.Length);
stream.Write(obj.CodeEncKey, 0, obj.CodeEncKey.Length);
stream.WriteLittleEndian(obj.OriginalCertificateSize);
stream.WriteLittleEndian(obj.OnlineService);
stream.WriteLittleEndian(obj.SecurityFlags);
stream.Write(obj.CodeEncKey);
}
public static void SerializeXbox360Certificate(Stream stream, Data.Models.XenonExecutable.Certificate obj)
{
byte[] length = BitConverter.GetBytes(obj.Length);
stream.Write(length, 0, length.Length);
byte[] imageSize = BitConverter.GetBytes(obj.ImageSize);
stream.Write(imageSize, 0, imageSize.Length);
stream.Write(obj.Signature, 0, obj.Signature.Length);
byte[] baseFileLoadAddress = BitConverter.GetBytes(obj.BaseFileLoadAddress);
stream.Write(baseFileLoadAddress, 0, baseFileLoadAddress.Length);
byte[] imageFlags = BitConverter.GetBytes(obj.ImageFlags);
stream.Write(imageFlags, 0, imageFlags.Length);
byte[] imageBaseAddress = BitConverter.GetBytes(obj.ImageBaseAddress);
stream.Write(imageBaseAddress, 0, imageBaseAddress.Length);
stream.Write(obj.UnknownHash1, 0, obj.UnknownHash1.Length);
byte[] unknown0128 = BitConverter.GetBytes(obj.Unknown0128);
stream.Write(unknown0128, 0, unknown0128.Length);
stream.Write(obj.UnknownHash2, 0, obj.UnknownHash2.Length);
stream.Write(obj.MediaID, 0, obj.MediaID.Length);
stream.Write(obj.XEXFileKey, 0, obj.XEXFileKey.Length);
byte[] unknown0160 = BitConverter.GetBytes(obj.Unknown0160);
stream.Write(unknown0160, 0, unknown0160.Length);
stream.Write(obj.UnknownHash3, 0, obj.UnknownHash3.Length);
byte[] regionFlags = BitConverter.GetBytes(obj.RegionFlags);
stream.Write(regionFlags, 0, regionFlags.Length);
byte[] allowedMediaTypeFlags = BitConverter.GetBytes(obj.AllowedMediaTypeFlags);
stream.Write(allowedMediaTypeFlags, 0, allowedMediaTypeFlags.Length);
byte[] tableCount = BitConverter.GetBytes(obj.TableCount);
stream.Write(tableCount, 0, tableCount.Length);
stream.WriteLittleEndian(obj.Length);
stream.WriteLittleEndian(obj.ImageSize);
stream.Write(obj.Signature);
stream.WriteLittleEndian(obj.BaseFileLoadAddress);
stream.WriteLittleEndian(obj.ImageFlags);
stream.WriteLittleEndian(obj.ImageBaseAddress);
stream.Write(obj.UnknownHash1);
stream.WriteLittleEndian(obj.Unknown0128);
stream.Write(obj.UnknownHash2);
stream.Write(obj.MediaID);
stream.Write(obj.XEXFileKey);
stream.WriteLittleEndian(obj.Unknown0160);
stream.Write(obj.UnknownHash3);
stream.WriteLittleEndian(obj.RegionFlags);
stream.WriteLittleEndian(obj.AllowedMediaTypeFlags);
stream.WriteLittleEndian(obj.TableCount);
for (int i = 0; i < obj.Table.Length; i++)
{
byte[] id = BitConverter.GetBytes(obj.Table[i].ID);
stream.Write(id, 0, id.Length);
stream.Write(obj.Table[i].Data, 0, obj.Table[i].Data.Length);
stream.WriteLittleEndian(obj.Table[i].ID);
stream.Write(obj.Table[i].Data);
}
}
}

3
SabreTools.Wrappers/BSP.Extraction.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using SabreTools.Data.Models.BSP;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -81,7 +82,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

3
SabreTools.Wrappers/GCF.Extraction.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.IO;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -97,7 +98,7 @@ namespace SabreTools.Wrappers
if (data.Length == 0)
return false;
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
}

3
SabreTools.Wrappers/InstallShieldArchiveV3.Extraction.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using SabreTools.IO.Compression.Blast;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -110,7 +111,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

3
SabreTools.Wrappers/MicrosoftCabinet.cs
View File

@@ -3,6 +3,7 @@ using System.IO;
using SabreTools.Data.Models.MicrosoftCabinet;
using SabreTools.IO.Compression.MSZIP;
using SabreTools.IO.Extensions;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -200,7 +201,7 @@ namespace SabreTools.Wrappers
Console.Error.WriteLine($"Data block {blockIndex} in folder {folderIndex} had mismatching sizes. Expected: {block.UncompressedSize}, Got: {stream.Length}");
byte[] padding = new byte[block.UncompressedSize - stream.Length];
stream.Write(padding, 0, padding.Length);
stream.Write(padding);
}
// Return the byte array data

2
SabreTools.Wrappers/NewExecutable.Extraction.cs
View File

@@ -176,7 +176,7 @@ namespace SabreTools.Wrappers
if (buffer.Length == 0)
break;
tempStream.Write(buffer, 0, buffer.Length);
tempStream.Write(buffer);
tempStream.Flush();
currentOffset += bytesToRead;

3
SabreTools.Wrappers/PAK.Extraction.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.IO;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -67,7 +68,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

8
SabreTools.Wrappers/PortableExecutable.Extraction.cs
View File

@@ -96,7 +96,7 @@ namespace SabreTools.Wrappers
// Write the output file
var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
@@ -151,7 +151,7 @@ namespace SabreTools.Wrappers
// Write the file data to a temp file
var tempStream = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
tempStream.Write(data, 0, data.Length);
tempStream.Write(data);
tempStream.Flush();
return true;
@@ -317,7 +317,7 @@ namespace SabreTools.Wrappers
if (buffer.Length == 0)
break;
tempStream.Write(buffer, 0, buffer.Length);
tempStream.Write(buffer);
tempStream.Flush();
currentOffset += bytesToRead;
@@ -614,7 +614,7 @@ namespace SabreTools.Wrappers
// Write the output file
var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}

2
SabreTools.Wrappers/Quantum.Extraction.cs
View File

@@ -102,7 +102,7 @@ namespace SabreTools.Wrappers
// {
// // Open the output file for writing
// using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
// fs.Write(data, 0, data.Length);
// fs.Write(data);
// fs.Flush();
// }
// catch

3
SabreTools.Wrappers/SGA.Extraction.cs
View File

@@ -2,6 +2,7 @@ using System;
using System.Collections.Generic;
using System.IO;
using SabreTools.IO.Compression.zlib;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -135,7 +136,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

3
SabreTools.Wrappers/SecuROMMatroschkaPackage.Extraction.cs
View File

@@ -2,6 +2,7 @@ using System;
using System.IO;
using SabreTools.Data.Models.SecuROM;
using SabreTools.Hashing;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -71,7 +72,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

3
SabreTools.Wrappers/TapeArchive.Extraction.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using SabreTools.Data.Models.TAR;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -148,7 +149,7 @@ namespace SabreTools.Wrappers
// Write the file
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(dataBytes, 0, dataBytes.Length);
fs.Write(dataBytes);
fs.Flush();
}

3
SabreTools.Wrappers/VBSP.Extraction.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using SabreTools.Data.Models.BSP;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -81,7 +82,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

2
SabreTools.Wrappers/VPK.Extraction.cs
View File

@@ -129,7 +129,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

3
SabreTools.Wrappers/WAD3.Extraction.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.IO;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -67,7 +68,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)

4
SabreTools.Wrappers/WiseSectionHeader.Extraction.cs
View File

@@ -157,7 +157,7 @@ namespace SabreTools.Wrappers
}
}
destination.Write(actual, 0, actual.Length);
destination.Write(actual);
return ExtractionStatus.GOOD;
}
catch
@@ -199,7 +199,7 @@ namespace SabreTools.Wrappers
// Debug output
if (includeDebug) Console.WriteLine("No CRC-32!");
destination.Write(actual, 0, actual.Length);
destination.Write(actual);
return ExtractionStatus.GOOD;
}
catch

4
SabreTools.Wrappers/XRD.Printing.cs
View File

@@ -61,10 +61,10 @@ namespace SabreTools.Wrappers
builder.AppendLine(Model.SecuritySectors[i], $"Security Sector {i}");
}
}
if (Model.XboxCertificate is not null)
XboxExecutable.Print(builder, Model.XboxCertificate);
if (Model.Xbox360Certificate is not null)
XenonExecutable.Print(builder, Model.Xbox360Certificate);

3
SabreTools.Wrappers/XZP.Extraction.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.IO;
using SabreTools.Numerics.Extensions;
namespace SabreTools.Wrappers
{
@@ -76,7 +77,7 @@ namespace SabreTools.Wrappers
{
// Open the output file for writing
using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.None);
fs.Write(data, 0, data.Length);
fs.Write(data);
fs.Flush();
}
catch (Exception ex)