protected override void ReadFromReader(MarkingBinaryReader reader) { UnpSize = reader.ReadInt16(); UnpVersion = reader.ReadByte(); UnpMethod = reader.ReadByte(); CommCRC = reader.ReadInt16(); }
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) { uint lowUncompressedSize = reader.ReadUInt32(); HostOS = (HostOS)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)) { // verify that the end of the header hasn't been reached before reading the Extended Time. // some tools incorrectly omit Extended Time despite specifying FileFlags.EXTTIME, which most parsers tolerate. if (ReadBytes + reader.CurrentReadByteCount <= HeaderSize - 2) { 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); } }