private static long FindNextEntry(Core.Utility.BinaryReader reader, GZipMemberEntry currentEntry)
{
var foundMagic = false;
var positionOfNextEntry = -1L;
try
{
var magic = reader.ReadByte();
while (true)
{
if (magic == MagicIdentifier[0])
{
magic = reader.ReadByte();
if (magic == MagicIdentifier[1])
{
foundMagic = true;
break;
}
}
else
{
magic = reader.ReadByte();
}
}
}
catch (EndOfStreamException)
{
positionOfNextEntry = reader.BaseStream.Length;
}
catch (IOException)
{
}
if (foundMagic || (positionOfNextEntry == reader.BaseStream.Length))
{
// go back 4 (CRC32) + 4 (size mod 2^32) [+ 2 (magic)]
var offset = sizeof(uint) + sizeof(int);
var origin = SeekOrigin.End;
if (foundMagic)
{
offset += MagicIdentifier.Length;
origin = SeekOrigin.Current;
}
reader.BaseStream.Seek(-offset, origin);
currentEntry.Crc32 = reader.ReadUInt32();
currentEntry._length = reader.ReadInt32();
positionOfNextEntry = reader.BaseStream.Position;
}
return(positionOfNextEntry);
}
private static uint DecodeLength(Core.Utility.BinaryReader reader, out int additionalBytesInPayloadLength)
{
var data = reader.ReadByte();
uint payloadLength = (uint)(data & ~PayloadLengthMask); // low 6 bits are the low 6 bits of payload length
additionalBytesInPayloadLength = (data & PayloadLengthMask) >> PayloadLengthBitShift;
for (var i = 0; i < additionalBytesInPayloadLength; ++i)
{
uint partialLengthBits = reader.ReadByte();
partialLengthBits = partialLengthBits << ((i * 8) + PayloadLengthBitShift);
payloadLength |= partialLengthBits;
}
return(payloadLength);
}
private static GZipOS ReadOperatingSystem(Core.Utility.BinaryReader reader, ref int bytesRead)
{
var operatingSystem = (GZipOS)reader.ReadByte();
bytesRead += sizeof(GZipOS);
return(operatingSystem);
}
private static ExtraFlags ReadExtraFlags(Core.Utility.BinaryReader reader, ref int bytesRead)
{
var extraFlags = (ExtraFlags)reader.ReadByte();
bytesRead += sizeof(ExtraFlags);
return(extraFlags);
}
private static CfgVarMetadataIdTag DecodeBlockType(Core.Utility.BinaryReader reader)
{
var type = CfgVarMetadataIdTag.Invalid;
var payloadLength = reader.BaseStream.Length;
var data = new byte[payloadLength];
var bytesRead = 0;
var foundEquals = false;
while (!foundEquals && (bytesRead < payloadLength))
{
var byteChar = reader.ReadByte();
var character = Convert.ToChar(byteChar);
foundEquals = character == '=';
if (!foundEquals)
{
data[bytesRead++] = byteChar;
}
}
if (foundEquals)
{
var tagString = System.Text.Encoding.UTF8.GetString(data, 0, data.Length).Trim('\0').Trim();
type = tagString.ToCfgVarMetadataIdTag();
}
return(type);
}
/// <inheritdoc/>
protected override int DeserializePayload(Core.Utility.BinaryReader reader)
{
// This is inefficient, but simple. Read and walk the payload twice. First time validates its checksum. Second pass actually parses it.
base.DeserializePayload(reader);
reader.BaseStream.Seek(-Length, System.IO.SeekOrigin.Current);
var runningBytesRead = 0;
while (runningBytesRead < Length)
{
var tag = (LuigiMetadataIdTag)reader.ReadByte();
++runningBytesRead;
var dataLength = reader.ReadByte();
++runningBytesRead;
MetadataParser parser;
if (!MetadataParsers.TryGetValue(tag, out parser))
{
parser = DefaultMetadataParser;
}
var metadata = parser(reader, dataLength);
runningBytesRead += dataLength;
switch (tag)
{
case LuigiMetadataIdTag.Date:
var date = (MetadataDateTime)metadata;
_releaseDates.Add(date);
break;
default:
List <string> metadataStringStorage;
if (_stringMetadataEntries.TryGetValue(tag, out metadataStringStorage))
{
var stringResult = (string)metadata;
metadataStringStorage.Add(stringResult);
}
else
{
System.Diagnostics.Debug.WriteLine("Either failed to parse or could not find storage for tag: " + tag);
}
break;
}
}
return(Length);
}
private static MetadataFlags ReadFlags(Core.Utility.BinaryReader reader, ref int bytesRead)
{
var flags = (MetadataFlags)reader.ReadByte();
bytesRead += sizeof(MetadataFlags);
if (flags.HasFlag(MetadataFlags.Reserved5 | MetadataFlags.Reserved6 | MetadataFlags.Reserved7))
{
throw new InvalidOperationException(Resources.Strings.GZipHeaderError_ReservedFlagsSet);
}
return(flags);
}
private static CompressionMethod ReadCompressionMethod(Core.Utility.BinaryReader reader, ref int bytesRead)
{
var compressionMethod = (CompressionMethod)reader.ReadByte();
bytesRead += sizeof(CompressionMethod);
if (compressionMethod != CompressionMethod.Deflate)
{
throw new InvalidOperationException(Resources.Strings.GZipHeaderError_InvalidCompression);
}
return(compressionMethod);
}
/// <inheritdoc />
/// <remarks>The precondition here is that the reader is positioned immediately after the LUIGI block type value.</remarks>
public override int Deserialize(Core.Utility.BinaryReader reader)
{
Length = reader.ReadUInt16();
var bytesRead = PayloadLengthSize;
HeaderCrc = reader.ReadByte();
bytesRead += HeaderChecksumSize;
ValidateHeaderCrc();
if (Length > 0)
{
PayloadCrc = reader.ReadUInt32();
bytesRead += PayloadChecksumSize;
bytesRead += DeserializePayload(reader);
}
return(bytesRead);
}
private static string ReadNullTerminatedString(Core.Utility.BinaryReader reader, ref int bytesRead)
{
var fileNameBytes = new List <byte>();
byte currentCharacter = 0;
do
{
currentCharacter = reader.ReadByte();
++bytesRead;
fileNameBytes.Add(currentCharacter);
}while (currentCharacter != 0);
var encoding = Encoding.GetEncoding("iso-8859-1");
var stringValue = encoding.GetString(fileNameBytes.ToArray(), 0, fileNameBytes.Count - 1);
return(stringValue);
}
/// <inheritdoc />
/// <remarks>The precondition here is that the reader is positioned immediately after the ROM metadata block type.</remarks>
public override int Deserialize(Core.Utility.BinaryReader reader)
{
int deserializedPayloadLength = 0;
var payloadLength = reader.BaseStream.Length;
var data = new byte[payloadLength];
try
{
while (deserializedPayloadLength < payloadLength)
{
data[deserializedPayloadLength++] = reader.ReadByte();
}
}
catch (System.IO.EndOfStreamException)
{
}
var payload = ConvertPayloadToString(data);
Parse(payload);
return(deserializedPayloadLength);
}
/// <inheritdoc />
public override int Deserialize(Core.Utility.BinaryReader reader)
{
var header = reader.ReadBytes(MagicKey.Length);
var bytesRead = header.Length;
if (!header.SequenceEqual(MagicKey))
{
throw new INTV.Core.UnexpectedFileTypeException("LUIGI");
}
Version = reader.ReadByte();
bytesRead += sizeof(byte);
if (Version > LuigiFileHeader.CurrentVersion)
{
// Perhaps throwing here is a bad idea...
throw new System.InvalidOperationException(string.Format(System.Globalization.CultureInfo.CurrentCulture, Resources.Strings.UnsupportedLuigiVersion_Format, Version));
}
Features = (LuigiFeatureFlags)reader.ReadUInt64();
bytesRead += sizeof(LuigiFeatureFlags);
if (Version > 0)
{
Features2 = (LuigiFeatureFlags2)reader.ReadUInt64();
bytesRead += sizeof(LuigiFeatureFlags2);
var uidBytes = reader.ReadBytes(VersionOneUidSize);
if (uidBytes.Length < sizeof(ulong))
{
throw new System.IO.EndOfStreamException();
}
Uid = BitConverter.ToUInt64(uidBytes, 0);
bytesRead += sizeof(ulong);
var originalFormatKey = uidBytes.Skip(OriginalRomCrc32Size).Take(OriginalRomKeySize);
var originalCrcData = uidBytes.Take(OriginalRomCrc32Size).ToArray();
if (originalFormatKey.SequenceEqual(RomKey))
{
OriginalRomFormat = RomFormat.Rom;
OriginalRomCrc32 = BitConverter.ToUInt32(originalCrcData, 0);
}
else
{
OriginalRomFormat = RomFormat.Bin;
OriginalRomCrc32 = BitConverter.ToUInt32(originalCrcData, 0);
if (!originalFormatKey.SequenceEqual(BinKey))
{
OriginalCfgCrc32 = BitConverter.ToUInt32(originalFormatKey.ToArray(), 0);
}
}
}
Reserved = reader.ReadBytes(ReservedHeaderBytesSize);
bytesRead += ReservedHeaderBytesSize;
Crc = reader.ReadByte();
bytesRead += HeaderChecksumSize;
ValidateHeaderBytesRead(bytesRead);
ValidateHeaderCrc(reader, bytesRead);
_deserializeByteCount = bytesRead;
return(bytesRead);
}