示例#1
0
 protected override void ReadFinish(MarkingBinaryReader reader)
 {
     CreationTime = reader.ReadInt32();
     ArcNameSize  = reader.ReadInt16();
     UserNameSize = reader.ReadInt16();
 }
示例#2
0
        private void ReadFromReaderV4(MarkingBinaryReader reader)
        {
            Flags      = HeaderFlags;
            IsSolid    = HasFlag(FileFlagsV4.SOLID);
            WindowSize = IsDirectory ? 0U : ((size_t)0x10000) << ((Flags & FileFlagsV4.WINDOW_MASK) >> 5);

            uint lowUncompressedSize = reader.ReadUInt32();

            HostOs = reader.ReadByte();

            FileCrc = reader.ReadUInt32();

            FileLastModifiedTime = Utility.DosDateToDateTime(reader.ReadUInt32());

            CompressionAlgorithm = reader.ReadByte();
            CompressionMethod    = (byte)(reader.ReadByte() - 0x30);

            short nameSize = reader.ReadInt16();

            FileAttributes = reader.ReadUInt32();

            uint highCompressedSize    = 0;
            uint highUncompressedkSize = 0;

            if (HasFlag(FileFlagsV4.LARGE))
            {
                highCompressedSize    = reader.ReadUInt32();
                highUncompressedkSize = reader.ReadUInt32();
            }
            else
            {
                if (lowUncompressedSize == 0xffffffff)
                {
                    lowUncompressedSize   = 0xffffffff;
                    highUncompressedkSize = int.MaxValue;
                }
            }
            CompressedSize   = UInt32To64(highCompressedSize, checked ((uint)AdditionalDataSize));
            UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);

            nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;

            byte[] fileNameBytes = reader.ReadBytes(nameSize);

            const int saltSize   = 8;
            const int newLhdSize = 32;

            switch (HeaderCode)
            {
            case HeaderCodeV.RAR4_FILE_HEADER:
            {
                if (HasFlag(FileFlagsV4.UNICODE))
                {
                    int length = 0;
                    while (length < fileNameBytes.Length &&
                           fileNameBytes[length] != 0)
                    {
                        length++;
                    }
                    if (length != nameSize)
                    {
                        length++;
                        FileName = FileNameDecoder.Decode(fileNameBytes, length);
                    }
                    else
                    {
                        FileName = ArchiveEncoding.Decode(fileNameBytes);
                    }
                }
                else
                {
                    FileName = ArchiveEncoding.Decode(fileNameBytes);
                }
                FileName = ConvertPathV4(FileName);
            }
            break;

            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
            {
                int datasize = HeaderSize - newLhdSize - nameSize;
                if (HasFlag(FileFlagsV4.SALT))
                {
                    datasize -= saltSize;
                }
                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 (HasFlag(FileFlagsV4.SALT))
            {
                R4Salt = reader.ReadBytes(saltSize);
            }
            if (HasFlag(FileFlagsV4.EXT_TIME))
            {
                // 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 (RemainingHeaderBytes(reader) >= 2)
                {
                    ushort extendedFlags = reader.ReadUInt16();
                    FileLastModifiedTime = ProcessExtendedTimeV4(extendedFlags, FileLastModifiedTime, reader, 0);
                    FileCreatedTime      = ProcessExtendedTimeV4(extendedFlags, null, reader, 1);
                    FileLastAccessedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 2);
                    FileArchivedTime     = ProcessExtendedTimeV4(extendedFlags, null, reader, 3);
                }
            }
        }
示例#3
0
        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);
                }
            }
        }