protected override void ReadFromReader(MarkingBinaryReader reader)
{
HighPosAv = reader.ReadInt16();
PosAv = reader.ReadInt32();
if (ArchiveHeaderFlags.HasFlag(ArchiveFlags.ENCRYPTVER))
{
EncryptionVersion = reader.ReadByte();
}
}
protected override void ReadFromReader(MarkingBinaryReader reader)
{
if (EndArchiveFlags.HasFlag(EndArchiveFlags.EARC_DATACRC))
{
ArchiveCRC = reader.ReadInt32();
}
if (EndArchiveFlags.HasFlag(EndArchiveFlags.EARC_VOLNUMBER))
{
VolumeNumber = reader.ReadInt16();
}
}
protected override void ReadFromReader(MarkingBinaryReader reader)
{
if (this.EndArchiveFlags_HasFlag(SharpCompress.Common.Rar.Headers.EndArchiveFlags.EARC_DATACRC))
{
this.ArchiveCRC = new int?(reader.ReadInt32());
}
if (this.EndArchiveFlags_HasFlag(SharpCompress.Common.Rar.Headers.EndArchiveFlags.EARC_VOLNUMBER))
{
this.VolumeNumber = new short?(reader.ReadInt16());
}
}
protected override void ReadFinish(MarkingBinaryReader reader)
{
if (IsRar5)
{
Flags = reader.ReadRarVIntUInt16();
}
else
{
Flags = HeaderFlags;
if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
{
ArchiveCrc = reader.ReadInt32();
}
if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
{
VolumeNumber = reader.ReadInt16();
}
}
}
protected override void ReadFromReader(MarkingBinaryReader reader)
{
uint lowUncompressedSize = reader.ReadUInt32();
HostOS = (HostOS)(int)reader.ReadByte();
FileCRC = reader.ReadUInt32();
FileLastModifiedTime = Utility.DosDateToDateTime(reader.ReadInt32());
RarVersion = reader.ReadByte();
PackingMethod = reader.ReadByte();
short nameSize = reader.ReadInt16();
FileAttributes = reader.ReadInt32();
uint highCompressedSize = 0;
uint highUncompressedkSize = 0;
if (FileFlags.HasFlag(FileFlags.LARGE))
{
highCompressedSize = reader.ReadUInt32();
highUncompressedkSize = reader.ReadUInt32();
}
else
{
if (lowUncompressedSize == 0xffffffff)
{
lowUncompressedSize = 0xffffffff;
highUncompressedkSize = int.MaxValue;
}
}
CompressedSize = UInt32To64(highCompressedSize, AdditionalSize);
UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);
nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
byte[] fileNameBytes = reader.ReadBytes(nameSize);
switch (HeaderType)
{
case HeaderType.FileHeader:
{
if (FileFlags.HasFlag(FileFlags.UNICODE))
{
int length = 0;
while (length < fileNameBytes.Length &&
fileNameBytes[length] != 0)
{
length++;
}
if (length != nameSize)
{
length++;
FileName = FileNameDecoder.Decode(fileNameBytes, length);
}
else
{
FileName = DecodeDefault(fileNameBytes);
}
}
else
{
FileName = DecodeDefault(fileNameBytes);
}
FileName = ConvertPath(FileName, HostOS);
}
break;
case HeaderType.NewSubHeader:
{
int datasize = HeaderSize - NEWLHD_SIZE - nameSize;
if (FileFlags.HasFlag(FileFlags.SALT))
{
datasize -= SALT_SIZE;
}
if (datasize > 0)
{
SubData = reader.ReadBytes(datasize);
}
if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
{
RecoverySectors = SubData[8] + (SubData[9] << 8)
+ (SubData[10] << 16) + (SubData[11] << 24);
}
}
break;
}
if (FileFlags.HasFlag(FileFlags.SALT))
{
Salt = reader.ReadBytes(SALT_SIZE);
}
if (FileFlags.HasFlag(FileFlags.EXTTIME))
{
ushort extendedFlags = reader.ReadUInt16();
FileLastModifiedTime = ProcessExtendedTime(extendedFlags, FileLastModifiedTime, reader, 0);
FileCreatedTime = ProcessExtendedTime(extendedFlags, null, reader, 1);
FileLastAccessedTime = ProcessExtendedTime(extendedFlags, null, reader, 2);
FileArchivedTime = ProcessExtendedTime(extendedFlags, null, reader, 3);
}
}
protected override void ReadFromReader(MarkingBinaryReader reader)
{
CreationTime = reader.ReadInt32();
ArcNameSize = reader.ReadInt16();
UserNameSize = reader.ReadInt16();
}
protected override void ReadFromReader(MarkingBinaryReader reader)
{
uint y = reader.ReadUInt32();
this.HostOS = (SharpCompress.Common.Rar.Headers.HostOS)reader.ReadByte();
this.FileCRC = reader.ReadUInt32();
this.FileLastModifiedTime = new DateTime?(Utility.DosDateToDateTime(reader.ReadInt32()));
this.RarVersion = reader.ReadByte();
this.PackingMethod = reader.ReadByte();
short count = reader.ReadInt16();
this.FileAttributes = reader.ReadInt32();
uint x = 0;
uint num4 = 0;
if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.LARGE))
{
x = reader.ReadUInt32();
num4 = reader.ReadUInt32();
}
else if (y == uint.MaxValue)
{
y = uint.MaxValue;
num4 = 0x7fffffff;
}
this.CompressedSize = this.UInt32To64(x, base.AdditionalSize);
this.UncompressedSize = this.UInt32To64(num4, y);
count = (count > 0x1000) ? ((short)0x1000) : count;
byte[] name = reader.ReadBytes(count);
switch (base.HeaderType)
{
case HeaderType.FileHeader:
if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.UNICODE))
{
int index = 0;
while ((index < name.Length) && (name[index] != 0))
{
index++;
}
if (index != count)
{
index++;
this.FileName = FileNameDecoder.Decode(name, index);
}
else
{
this.FileName = this.DecodeDefault(name);
}
}
else
{
this.FileName = this.DecodeDefault(name);
}
this.FileName = ConvertPath(this.FileName, this.HostOS);
break;
case HeaderType.NewSubHeader:
{
int num6 = (base.HeaderSize - 0x20) - count;
if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.SALT))
{
num6 -= 8;
}
if (num6 > 0)
{
this.SubData = reader.ReadBytes(num6);
}
if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(name))
{
this.RecoverySectors = ((this.SubData[8] + (this.SubData[9] << 8)) + (this.SubData[10] << 0x10)) + (this.SubData[11] << 0x18);
}
break;
}
}
if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.SALT))
{
this.Salt = reader.ReadBytes(8);
}
if (this.FileFlags_HasFlag(SharpCompress.Common.Rar.Headers.FileFlags.EXTTIME) && ((base.ReadBytes + reader.CurrentReadByteCount) <= (base.HeaderSize - 2)))
{
ushort extendedFlags = reader.ReadUInt16();
this.FileLastModifiedTime = ProcessExtendedTime(extendedFlags, this.FileLastModifiedTime, reader, 0);
DateTime?time = null;
this.FileCreatedTime = ProcessExtendedTime(extendedFlags, time, reader, 1);
time = null;
this.FileLastAccessedTime = ProcessExtendedTime(extendedFlags, time, reader, 2);
this.FileArchivedTime = ProcessExtendedTime(extendedFlags, null, reader, 3);
}
}
