public void TestIncompleteRewind() { MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); bw.Write(1); bw.Write(2); bw.Write(3); bw.Write(4); bw.Write(5); bw.Write(6); bw.Write(7); bw.Flush(); ms.Position = 0; RewindableStream stream = new RewindableStream(ms); stream.StartRecording(); BinaryReader br = new BinaryReader(stream); Assert.AreEqual(br.ReadInt32(), 1); Assert.AreEqual(br.ReadInt32(), 2); Assert.AreEqual(br.ReadInt32(), 3); Assert.AreEqual(br.ReadInt32(), 4); stream.Rewind(true); Assert.AreEqual(br.ReadInt32(), 1); Assert.AreEqual(br.ReadInt32(), 2); stream.StartRecording(); Assert.AreEqual(br.ReadInt32(), 3); Assert.AreEqual(br.ReadInt32(), 4); Assert.AreEqual(br.ReadInt32(), 5); stream.Rewind(true); Assert.AreEqual(br.ReadInt32(), 3); Assert.AreEqual(br.ReadInt32(), 4); Assert.AreEqual(br.ReadInt32(), 5); Assert.AreEqual(br.ReadInt32(), 6); Assert.AreEqual(br.ReadInt32(), 7); }
internal GZipFilePart(Stream stream) { RewindableStream rewind = new RewindableStream(stream); rewind.Recording = true; ReadAndValidateGzipHeader(rewind); rewind.Rewind(); this.stream = new GZipStream(rewind, CompressionMode.Decompress); }
public RewindableStream(Stream stream, MemoryStream bufferStream) { this.bufferStream = new MemoryStream(); RewindableStream stream2 = stream as RewindableStream; this.stream = ((stream2 == null) || stream2.isRewound) ? stream : stream2.stream; this.bufferStream = bufferStream; if (bufferStream.Position != bufferStream.Length) { this.isRewound = true; } }
internal IEnumerable<ZipHeader> ReadStreamHeader(Stream stream) { RewindableStream rewindableStream; if (stream is NonDisposingStream) { stream = ((NonDisposingStream) stream).Stream; } if (stream is RewindableStream) { rewindableStream = stream as RewindableStream; } else { rewindableStream = new RewindableStream(stream); } while (true) { ZipHeader header = null; BinaryReader reader = new BinaryReader(rewindableStream); if (lastEntryHeader != null && FlagUtility.HasFlag(lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)) { reader = (lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream); long pos = rewindableStream.Position; uint crc = reader.ReadUInt32(); if (crc == POST_DATA_DESCRIPTOR) { crc = reader.ReadUInt32(); } lastEntryHeader.Crc = crc; lastEntryHeader.CompressedSize = reader.ReadUInt32(); lastEntryHeader.UncompressedSize = reader.ReadUInt32(); lastEntryHeader.DataStartPosition = pos - lastEntryHeader.CompressedSize; } lastEntryHeader = null; uint headerBytes = reader.ReadUInt32(); header = ReadHeader(headerBytes, reader); //entry could be zero bytes so we need to know that. if (header.ZipHeaderType == ZipHeaderType.LocalEntry) { bool isRecording = rewindableStream.IsRecording; if (!isRecording) { rewindableStream.StartRecording(); } uint nextHeaderBytes = reader.ReadUInt32(); header.HasData = !IsHeader(nextHeaderBytes); rewindableStream.Rewind(!isRecording); } yield return header; } }
/// <summary> /// Opens a Reader for Non-seeking usage /// </summary> /// <param name="stream"></param> /// <param name="options"></param> /// <returns></returns> public static IReader Open(Stream stream, Options options = Options.KeepStreamsOpen) { stream.CheckNotNull("stream"); RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.StartRecording(); if (ZipArchive.IsZipFile(rewindableStream, null)) { rewindableStream.Rewind(true); return ZipReader.Open(rewindableStream, null, options); } rewindableStream.Rewind(false); if (GZipArchive.IsGZipFile(rewindableStream)) { rewindableStream.Rewind(false); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, CompressionType.GZip, options); } rewindableStream.Rewind(true); return GZipReader.Open(rewindableStream, options); } rewindableStream.Rewind(false); if (BZip2Stream.IsBZip2(rewindableStream)) { rewindableStream.Rewind(false); BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false); if (TarArchive.IsTarFile(testStream)) { rewindableStream.Rewind(true); return new TarReader(rewindableStream, CompressionType.BZip2, options); } } rewindableStream.Rewind(false); if (TarArchive.IsTarFile(rewindableStream)) { rewindableStream.Rewind(true); return TarReader.Open(rewindableStream, options); } rewindableStream.Rewind(false); if (RarArchive.IsRarFile(rewindableStream, options)) { rewindableStream.Rewind(true); return RarReader.Open(rewindableStream, options); } throw new InvalidOperationException("Cannot determine compressed stream type."); }
public static IReader Open(Stream stream, Options options) { Utility.CheckNotNull(stream, "stream"); RewindableStream stream2 = new RewindableStream(stream); stream2.StartRecording(); if (ZipArchive.IsZipFile(stream2, null)) { stream2.Rewind(true); return ZipReader.Open(stream2, null, options); } stream2.Rewind(false); if (GZipArchive.IsGZipFile(stream2)) { stream2.Rewind(false); GZipStream stream3 = new GZipStream(stream2, CompressionMode.Decompress); if (TarArchive.IsTarFile(stream3)) { stream2.Rewind(true); return new TarReader(stream2, CompressionType.GZip, options); } stream2.Rewind(true); return GZipReader.Open(stream2, options); } stream2.Rewind(false); if (BZip2Stream.IsBZip2(stream2)) { stream2.Rewind(false); BZip2Stream stream4 = new BZip2Stream(stream2, CompressionMode.Decompress, false, false); if (TarArchive.IsTarFile(stream4)) { stream2.Rewind(true); return new TarReader(stream2, CompressionType.BZip2, options); } } stream2.Rewind(false); if (TarArchive.IsTarFile(stream2)) { stream2.Rewind(true); return TarReader.Open(stream2, options); } stream2.Rewind(false); if (!RarArchive.IsRarFile(stream2, options)) { throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar"); } stream2.Rewind(true); return RarReader.Open(stream2, options); }
internal IEnumerable<ZipHeader> ReadStreamHeader(Stream stream) { RewindableStream iteratorVariable0; if (stream is RewindableStream) { iteratorVariable0 = stream as RewindableStream; } else { iteratorVariable0 = new RewindableStream(stream); } while (true) { ZipHeader iteratorVariable1 = null; BinaryReader reader = new BinaryReader(iteratorVariable0); if ((this.lastEntryHeader != null) && FlagUtility.HasFlag<HeaderFlags>(this.lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)) { reader = (this.lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref iteratorVariable0); long position = iteratorVariable0.Position; uint num2 = reader.ReadUInt32(); if (num2 == 0x8074b50) { num2 = reader.ReadUInt32(); } this.lastEntryHeader.Crc = num2; this.lastEntryHeader.CompressedSize = reader.ReadUInt32(); this.lastEntryHeader.UncompressedSize = reader.ReadUInt32(); this.lastEntryHeader.DataStartPosition = new long?(position - this.lastEntryHeader.CompressedSize); } this.lastEntryHeader = null; uint iteratorVariable3 = reader.ReadUInt32(); iteratorVariable1 = this.ReadHeader(iteratorVariable3, reader); if (iteratorVariable1.ZipHeaderType == ZipHeaderType.LocalEntry) { bool isRecording = iteratorVariable0.IsRecording; if (!isRecording) { iteratorVariable0.StartRecording(); } uint headerBytes = reader.ReadUInt32(); iteratorVariable1.HasData = !ZipHeaderFactory.IsHeader(headerBytes); iteratorVariable0.Rewind(!isRecording); } yield return iteratorVariable1; } }
public RewindableStream(Stream stream, MemoryStream bufferStream) { RewindableStream parent = stream as RewindableStream; if (parent != null && !parent.isRewound) { this.stream = parent.stream; } else { this.stream = stream; } this.bufferStream = bufferStream; if (bufferStream.Position != bufferStream.Length) { isRewound = true; } }
/// <summary> /// Opens a Reader for Non-seeking usage /// </summary> /// <param name="stream"></param> /// <param name="listener"></param> /// <param name="options"></param> /// <returns></returns> public static IReader OpenReader(Stream stream, IExtractionListener listener, Options options = Options.KeepStreamsOpen) { stream.CheckNotNull("stream"); RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.Recording = true; if (ZipArchive.IsZipFile(rewindableStream)) { return ZipReader.Open(rewindableStream, listener, options); } rewindableStream.Rewind(); rewindableStream.Recording = true; if (GZipReader.IsGZip(rewindableStream)) { rewindableStream.Rewind(); GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress); rewindableStream.Recording = true; if (TarReader.IsTarFile(testStream)) { rewindableStream.Rewind(); return TarGZipReader.Open(rewindableStream, listener, options); } rewindableStream.Rewind(); return GZipReader.Open(rewindableStream, listener, options); } rewindableStream.Rewind(); rewindableStream.Recording = true; if (TarReader.IsTarFile(rewindableStream)) { rewindableStream.Rewind(); return TarReader.Open(rewindableStream, listener, options); } rewindableStream.Rewind(); rewindableStream.Recording = true; if (RarArchive.IsRarFile(rewindableStream)) { rewindableStream.Rewind(); return RarReader.Open(rewindableStream, listener, options); } throw new InvalidOperationException("Cannot determine compressed stream type."); }
internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream) { if (base.Header.IsDirectory) { return new BinaryReader(rewindableStream); } if (base.Header.HasData) { if (this.decompressionStream == null) { this.decompressionStream = this.GetCompressedStream(); } Utility.SkipAll(this.decompressionStream); DeflateStream decompressionStream = this.decompressionStream as DeflateStream; if (decompressionStream != null) { rewindableStream.Rewind(decompressionStream.InputBuffer); } } BinaryReader reader = new BinaryReader(rewindableStream); this.decompressionStream = null; return reader; }
internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream) { if (Header.IsDirectory) { return new BinaryReader(rewindableStream); } if (Header.HasData) { if (decompressionStream == null) { decompressionStream = GetCompressedStream(); } //decompressionStream.SkipAll(); Utility.SkipAll(decompressionStream); DeflateStream deflateStream = decompressionStream as DeflateStream; if (deflateStream != null) { rewindableStream.Rewind(deflateStream.InputBuffer); } } var reader = new BinaryReader(rewindableStream); decompressionStream = null; return reader; }
public void Test() { MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); bw.Write(1); bw.Write(2); bw.Write(3); bw.Write(4); bw.Write(5); bw.Write(6); bw.Write(7); bw.Flush(); ms.Position = 0; RewindableStream stream = new RewindableStream(ms); stream.Recording = true; BinaryReader br = new BinaryReader(stream); Debug.Assert(br.ReadInt32() == 1); Debug.Assert(br.ReadInt32() == 2); Debug.Assert(br.ReadInt32() == 3); Debug.Assert(br.ReadInt32() == 4); stream.Rewind(); stream.Recording = true; Debug.Assert(br.ReadInt32() == 1); Debug.Assert(br.ReadInt32() == 2); Debug.Assert(br.ReadInt32() == 3); Debug.Assert(br.ReadInt32() == 4); Debug.Assert(br.ReadInt32() == 5); Debug.Assert(br.ReadInt32() == 6); Debug.Assert(br.ReadInt32() == 7); stream.Rewind(); stream.Recording = true; Debug.Assert(br.ReadInt32() == 1); Debug.Assert(br.ReadInt32() == 2); Debug.Assert(br.ReadInt32() == 3); Debug.Assert(br.ReadInt32() == 4); }
private RewindableStream GetRewindableStream(Stream stream) { RewindableStream rewindableStream = stream as RewindableStream; if (rewindableStream == null) { rewindableStream = new RewindableStream(stream); } return rewindableStream; }
private RewindableStream GetRewindableStream(Stream stream) { RewindableStream stream2 = stream as RewindableStream; if (stream2 == null) { stream2 = new RewindableStream(stream); } return stream2; }
internal IEnumerable<RarHeader> ReadHeaders(Stream stream) { if (Options.HasFlag(Options.CheckForSFX)) { RewindableStream rewindableStream = new RewindableStream(stream); rewindableStream.Recording = true; stream = rewindableStream; BinaryReader reader = new BinaryReader(rewindableStream); try { int count = 0; while (true) { byte firstByte = reader.ReadByte(); if (firstByte == 0x52) { byte[] nextThreeBytes = reader.ReadBytes(3); if ((nextThreeBytes[0] == 0x45) && (nextThreeBytes[1] == 0x7E) && (nextThreeBytes[2] == 0x5E)) { //old format and isvalid rewindableStream.Rewind(); break; } byte[] secondThreeBytes = reader.ReadBytes(3); if ((nextThreeBytes[0] == 0x61) && (nextThreeBytes[1] == 0x72) && (nextThreeBytes[2] == 0x21) && (secondThreeBytes[0] == 0x1A) && (secondThreeBytes[1] == 0x07) && (secondThreeBytes[2] == 0x00)) { //new format and isvalid rewindableStream.Rewind(); break; } } if (count > MAX_SFX_SIZE) { break; } } } catch (Exception e) { if (!Options.HasFlag(Options.KeepStreamsOpen)) { #if THREEFIVE reader.Close(); #else reader.Dispose(); #endif } throw new InvalidRarFormatException("Error trying to read rar signature.", e); } } RarHeader header; while ((header = ReadNextHeader(stream)) != null) { yield return header; if (header.HeaderType == HeaderType.EndArchiveHeader) { yield break; // the end? } } }