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 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);
}
/// <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;
}
/// <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);
}
#if GZIP
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);
}
#endif
#if BZIP2
rewindableStream.Rewind(false);
if (BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false);
#if TAR
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return new TarReader(rewindableStream, CompressionType.BZip2, options);
}
#endif
}
#endif
#if TAR
rewindableStream.Rewind(false);
if (TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
return TarReader.Open(rewindableStream, options);
}
#endif
#if RAR
rewindableStream.Rewind(false);
if (RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
return RarReader.Open(rewindableStream, options);
}
#endif
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar");
}
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<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?
}
}
}
