public static TarReader Open(Stream stream, Options options)
{
Utility.CheckNotNull(stream, "stream");
RewindableStream stream2 = new RewindableStream(stream);
stream2.StartRecording();
if (GZipArchive.IsGZipFile(stream2))
{
stream2.Rewind(false);
GZipStream stream3 = new GZipStream(stream2, CompressionMode.Decompress);
if (!TarArchive.IsTarFile(stream3))
{
throw new InvalidFormatException("Not a tar file.");
}
stream2.Rewind(true);
return(new TarReader(stream2, CompressionType.GZip, options));
}
stream2.Rewind(false);
if (BZip2Stream.IsBZip2(stream2))
{
stream2.Rewind(false);
BZip2Stream stream4 = new BZip2Stream(stream2, CompressionMode.Decompress, false, false);
if (!TarArchive.IsTarFile(stream4))
{
throw new InvalidFormatException("Not a tar file.");
}
stream2.Rewind(true);
return(new TarReader(stream2, CompressionType.BZip2, options));
}
stream2.Rewind(true);
return(new TarReader(stream2, CompressionType.None, options));
}
/// <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, ReaderOptions options = null)
{
stream.CheckNotNull(nameof(stream));
options = options != null ?options: new ReaderOptions()
{
LeaveStreamOpen = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
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, options, CompressionType.GZip));
}
rewindableStream.Rewind(true);
return(GZipReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
return(TarReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ");
}
internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream)
{
if (Header.IsDirectory)
{
return(new BinaryReader(rewindableStream));
}
if (Header.HasData)
{
if (decompressionStream == null)
{
decompressionStream = GetCompressedStream();
}
decompressionStream.SkipAll();
DeflateStream deflateStream = decompressionStream as DeflateStream;
if (deflateStream != null)
{
rewindableStream.Rewind(deflateStream.InputBuffer);
}
}
var reader = new BinaryReader(rewindableStream);
decompressionStream = null;
return(reader);
}
internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream)
{
if (Header.IsDirectory)
{
return(new BinaryReader(rewindableStream));
}
if (Header.HasData && !Skipped)
{
if (_decompressionStream == null)
{
_decompressionStream = GetCompressedStream();
}
_decompressionStream.Skip();
if (_decompressionStream is DeflateStream deflateStream)
{
rewindableStream.Rewind(deflateStream.InputBuffer);
}
Skipped = true;
}
var reader = new BinaryReader(rewindableStream);
_decompressionStream = null;
return(reader);
}
/// <summary>
/// Opens a TarReader for Non-seeking usage with a single volume
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static TarReader Open(Stream stream, Options options = Options.KeepStreamsOpen)
{
stream.CheckNotNull("stream");
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
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));
}
throw new InvalidFormatException("Not a tar file.");
}
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));
}
throw new InvalidFormatException("Not a tar file.");
}
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, CompressionType.None, options));
}
internal GZipFilePart(Stream stream)
{
RewindableStream rewind = new RewindableStream(stream);
rewind.Recording = true;
ReadAndValidateGzipHeader(rewind);
rewind.Rewind();
this.stream = new GZipStream(rewind, CompressionMode.Decompress);
}
internal IEnumerable <ZipHeader> ReadStreamHeader(Stream stream)
{
RewindableStream rewindableStream;
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) || _lastEntryHeader.IsZip64))
{
reader = (_lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream);
long?pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
uint crc = reader.ReadUInt32();
if (crc == POST_DATA_DESCRIPTOR)
{
crc = reader.ReadUInt32();
}
_lastEntryHeader.Crc = crc;
_lastEntryHeader.CompressedSize = reader.ReadUInt32();
_lastEntryHeader.UncompressedSize = reader.ReadUInt32();
if (pos.HasValue)
{
_lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
}
}
_lastEntryHeader = null;
uint headerBytes = reader.ReadUInt32();
header = ReadHeader(headerBytes, reader);
if (header == null)
{
yield break;
}
//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);
}
}
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);
}
private Stream CheckSFX(Stream stream)
{
RewindableStream rewindableStream = this.GetRewindableStream(stream);
stream = rewindableStream;
BinaryReader reader = new BinaryReader(rewindableStream);
try
{
bool flag;
int num = 0;
goto Label_0138;
Label_001B:
if (reader.ReadByte() == 0x52)
{
MemoryStream stream3 = new MemoryStream();
byte[] buffer = reader.ReadBytes(3);
if (((buffer[0] == 0x45) && (buffer[1] == 0x7e)) && (buffer[2] == 0x5e))
{
stream3.WriteByte(0x52);
stream3.Write(buffer, 0, 3);
rewindableStream.Rewind(stream3);
return(stream);
}
byte[] buffer2 = reader.ReadBytes(3);
if (((((buffer[0] == 0x61) && (buffer[1] == 0x72)) && ((buffer[2] == 0x21) && (buffer2[0] == 0x1a))) && (buffer2[1] == 7)) && (buffer2[2] == 0))
{
stream3.WriteByte(0x52);
stream3.Write(buffer, 0, 3);
stream3.Write(buffer2, 0, 3);
rewindableStream.Rewind(stream3);
return(stream);
}
stream3.Write(buffer, 0, 3);
stream3.Write(buffer2, 0, 3);
rewindableStream.Rewind(stream3);
}
if (num > 0x7fff0)
{
return(stream);
}
Label_0138:
flag = true;
goto Label_001B;
}
catch (Exception exception)
{
if (!this.Options_HasFlag(SharpCompress.Common.Options.KeepStreamsOpen))
{
reader.Close();
}
throw new InvalidFormatException("Error trying to read rar signature.", exception);
}
return(stream);
}
/// <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. 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 <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);
}
}
/// <summary>
/// Opens a TarReader for Non-seeking usage with a single volume
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static TarReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull(nameof(stream));
options = options ?? new ReaderOptions();
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
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, options, CompressionType.GZip));
}
throw new InvalidFormatException("Not a tar file.");
}
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, options, CompressionType.BZip2));
}
throw new InvalidFormatException("Not a tar file.");
}
rewindableStream.Rewind(false);
if (LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.LZip));
}
throw new InvalidFormatException("Not a tar file.");
}
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.None));
}
/// <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.");
}
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);
}
public void TestRewind()
{
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.Equal(br.ReadInt32(), 1);
Assert.Equal(br.ReadInt32(), 2);
Assert.Equal(br.ReadInt32(), 3);
Assert.Equal(br.ReadInt32(), 4);
stream.Rewind(true);
stream.StartRecording();
Assert.Equal(br.ReadInt32(), 1);
Assert.Equal(br.ReadInt32(), 2);
Assert.Equal(br.ReadInt32(), 3);
Assert.Equal(br.ReadInt32(), 4);
Assert.Equal(br.ReadInt32(), 5);
Assert.Equal(br.ReadInt32(), 6);
Assert.Equal(br.ReadInt32(), 7);
stream.Rewind(true);
stream.StartRecording();
Assert.Equal(br.ReadInt32(), 1);
Assert.Equal(br.ReadInt32(), 2);
Assert.Equal(br.ReadInt32(), 3);
Assert.Equal(br.ReadInt32(), 4);
}
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.Equal(1, br.ReadInt32());
Assert.Equal(2, br.ReadInt32());
Assert.Equal(3, br.ReadInt32());
Assert.Equal(4, br.ReadInt32());
stream.Rewind(true);
Assert.Equal(1, br.ReadInt32());
Assert.Equal(2, br.ReadInt32());
stream.StartRecording();
Assert.Equal(3, br.ReadInt32());
Assert.Equal(4, br.ReadInt32());
Assert.Equal(5, br.ReadInt32());
stream.Rewind(true);
Assert.Equal(3, br.ReadInt32());
Assert.Equal(4, br.ReadInt32());
Assert.Equal(5, br.ReadInt32());
Assert.Equal(6, br.ReadInt32());
Assert.Equal(7, br.ReadInt32());
}
public static IReader Open(Stream stream, Options options = 1)
{
stream.CheckNotNull("stream");
RewindableStream stream2 = new RewindableStream(stream);
stream2.StartRecording();
stream2.Rewind(false);
if (BZip2Stream.IsBZip2(stream2))
{
stream2.Rewind(false);
if (TarArchive.IsTarFile(new BZip2Stream(stream2, CompressionMode.Decompress, false, false)))
{
stream2.Rewind(true);
return(new TarReader(stream2, CompressionType.BZip2, options));
}
}
stream2.Rewind(false);
if (!TarArchive.IsTarFile(stream2))
{
throw new InvalidOperationException("Cannot determine compressed stream type.");
}
stream2.Rewind(true);
return(TarReader.Open(stream2, options));
}
public static Stream DecodeSin(Stream stream, long totalSize)
{
var rewindable = new RewindableStream(stream);
rewindable.StartRecording();
var reader = new BinaryReader(rewindable);
var version = reader.ReadByte();
switch (version)
{
case 1:
case 2:
throw new Exception($"SIN version 1 and 2 not supported.");
case 3:
rewindable.Rewind(true);
var tempStream = TempFileStream.Create();
SinParserV3.CopyTo(reader, tempStream);
return(tempStream);
}
rewindable.Rewind(true);
return(DecodeTarSin(rewindable, totalSize));
}
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 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?
}
}
}
public static bool TryOpen(Stream stream, ReaderOptions options, ArchiveTypeMask archiveTypes, out IReader reader)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions()
{
LeaveStreamOpen = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(rewindableStream, options.Password))
{
rewindableStream.Rewind(true);
reader = ZipReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.GZip);
return(true);
}
rewindableStream.Rewind(true);
reader = GZipReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.BZip2) && BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.BZip2);
return(true);
}
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.LZip) && LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.LZip);
return(true);
}
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
reader = RarReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
reader = TarReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (XZStream.IsXZStream(rewindableStream))
{
rewindableStream.Rewind(true);
XZStream testStream = new XZStream(rewindableStream);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.Xz);
return(true);
}
}
reader = null;
return(false);
}
internal IEnumerable <ZipHeader> ReadStreamHeader(Stream stream)
{
RewindableStream rewindableStream;
if (stream is RewindableStream rs)
{
rewindableStream = rs;
}
else
{
rewindableStream = new RewindableStream(stream);
}
while (true)
{
ZipHeader header;
BinaryReader reader = new BinaryReader(rewindableStream);
if (_lastEntryHeader != null &&
(FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || _lastEntryHeader.IsZip64))
{
reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(ref rewindableStream);
long?pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
uint crc = reader.ReadUInt32();
if (crc == POST_DATA_DESCRIPTOR)
{
crc = reader.ReadUInt32();
}
_lastEntryHeader.Crc = crc;
_lastEntryHeader.CompressedSize = reader.ReadUInt32();
_lastEntryHeader.UncompressedSize = reader.ReadUInt32();
if (pos.HasValue)
{
_lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
}
}
_lastEntryHeader = null;
uint headerBytes = reader.ReadUInt32();
header = ReadHeader(headerBytes, reader);
if (header is null)
{
yield break;
}
//entry could be zero bytes so we need to know that.
if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
{
var local_header = ((LocalEntryHeader)header);
// If we have CompressedSize, there is data to be read
if (local_header.CompressedSize > 0)
{
header.HasData = true;
} // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
else if (local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor))
{
bool isRecording = rewindableStream.IsRecording;
if (!isRecording)
{
rewindableStream.StartRecording();
}
uint nextHeaderBytes = reader.ReadUInt32();
// Check if next data is PostDataDescriptor, streamed file with 0 length
header.HasData = !IsHeader(nextHeaderBytes);
rewindableStream.Rewind(!isRecording);
}
else // We are not streaming and compressed size is 0, we have no data
{
header.HasData = false;
}
}
yield return(header);
}
}
private Stream CheckSFX(Stream stream)
{
RewindableStream rewindableStream = GetRewindableStream(stream);
stream = rewindableStream;
BinaryReader reader = new BinaryReader(rewindableStream);
try
{
int count = 0;
while (true)
{
byte firstByte = reader.ReadByte();
if (firstByte == 0x52)
{
MemoryStream buffer = new MemoryStream();
byte[] nextThreeBytes = reader.ReadBytes(3);
if ((nextThreeBytes[0] == 0x45) &&
(nextThreeBytes[1] == 0x7E) &&
(nextThreeBytes[2] == 0x5E))
{
//old format and isvalid
buffer.WriteByte(0x52);
buffer.Write(nextThreeBytes, 0, 3);
rewindableStream.Rewind(buffer);
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
buffer.WriteByte(0x52);
buffer.Write(nextThreeBytes, 0, 3);
buffer.Write(secondThreeBytes, 0, 3);
rewindableStream.Rewind(buffer);
break;
}
buffer.Write(nextThreeBytes, 0, 3);
buffer.Write(secondThreeBytes, 0, 3);
rewindableStream.Rewind(buffer);
}
if (count > MAX_SFX_SIZE)
{
break;
}
}
}
catch (Exception e)
{
if (!Options.LeaveStreamOpen)
{
#if NET35
reader.Close();
#else
reader.Dispose();
#endif
}
throw new InvalidFormatException("Error trying to read rar signature.", e);
}
return(stream);
}
internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream)
{
if (Header.IsDirectory)
{
return(new BinaryReader(rewindableStream));
}
if (Header.HasData && !Skipped)
{
_decompressionStream ??= GetCompressedStream();
if (Header.CompressionMethod != ZipCompressionMethod.None)
{
_decompressionStream.Skip();
// If we had TotalIn / TotalOut we could have used them
Header.CompressedSize = _decompressionStream.Position;
if (_decompressionStream is DeflateStream deflateStream)
{
rewindableStream.Rewind(deflateStream.InputBuffer);
}
}
else
{
// We would need to search for the magic word
rewindableStream.Position -= 4;
var pos = rewindableStream.Position;
while (Utility.Find(rewindableStream, new byte[] { 0x50, 0x4b, 0x07, 0x08 }))
{
// We should probably check CRC32 for positive matching as well
var size = rewindableStream.Position - pos;
var br = new BinaryReader(rewindableStream);
br.ReadUInt32();
br.ReadUInt32(); // CRC32
var compressed_size = br.ReadUInt32();
var uncompressed_size = br.ReadUInt32();
var uncompressed_64bit = br.ReadInt64();
long test_64bit = (long)uncompressed_size << 32 | (long)compressed_size;
if (test_64bit == size && test_64bit == uncompressed_64bit)
{
Header.CompressedSize = test_64bit;
Header.UncompressedSize = uncompressed_64bit;
rewindableStream.Position -= 24;
break;
}
if (compressed_size == size && compressed_size == uncompressed_size)
{
Header.CompressedSize = compressed_size;
Header.UncompressedSize = uncompressed_size;
rewindableStream.Position -= 24;
break;
}
rewindableStream.Position -= 20;
}
}
Skipped = true;
}
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, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions()
{
LeaveStreamOpen = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (ZipArchive.IsZipFile(rewindableStream, options.Password))
{
rewindableStream.Rewind(true);
return(ZipReader.Open(rewindableStream, 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, options, CompressionType.GZip));
}
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, true);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.BZip2));
}
}
rewindableStream.Rewind(false);
if (LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, true);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.LZip));
}
}
rewindableStream.Rewind(false);
if (RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
return(RarReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
return(TarReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (XZStream.IsXZStream(rewindableStream))
{
rewindableStream.Rewind(true);
XZStream testStream = new XZStream(rewindableStream);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.Xz));
}
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ");
}
