public ProtectHeader(RarHeader header, RarCrcBinaryReader reader)
: base(header, reader, HeaderType.Protect)
{
if (IsRar5)
{
throw new InvalidFormatException("unexpected rar5 record");
}
}
private void FillBase(RarHeader baseHeader)
{
HeadCRC = baseHeader.HeadCRC;
HeaderType = baseHeader.HeaderType;
Flags = baseHeader.Flags;
HeaderSize = baseHeader.HeaderSize;
AdditionalSize = baseHeader.AdditionalSize;
ReadBytes = baseHeader.ReadBytes;
}
private void FillBase(RarHeader baseHeader)
{
this.HeadCRC = baseHeader.HeadCRC;
this.HeaderType = baseHeader.HeaderType;
this.Flags = baseHeader.Flags;
this.HeaderSize = baseHeader.HeaderSize;
this.AdditionalSize = baseHeader.AdditionalSize;
this.ReadBytes = baseHeader.ReadBytes;
}
internal static RarHeader Create(MarkingBinaryReader reader)
{
try
{
RarHeader header = new RarHeader();
reader.Mark();
header.ReadFromReader(reader);
header.ReadBytes += reader.CurrentReadByteCount;
return(header);
}
catch (EndOfStreamException)
{
return(null);
}
}
internal static RarHeader Create(RarCrcBinaryReader reader, ArchiveEncoding archiveEncoding)
{
try
{
RarHeader header = new RarHeader();
header.ArchiveEncoding = archiveEncoding;
reader.Mark();
header.ReadStartFromReader(reader);
header.ReadBytes += reader.CurrentReadByteCount;
return header;
}
catch (EndOfStreamException)
{
return null;
}
}
protected RarHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
{
_headerType = headerType;
_isRar5 = header.IsRar5;
HeaderCrc = header.HeaderCrc;
HeaderCode = header.HeaderCode;
HeaderFlags = header.HeaderFlags;
HeaderSize = header.HeaderSize;
ExtraSize = header.ExtraSize;
AdditionalDataSize = header.AdditionalDataSize;
ArchiveEncoding = header.ArchiveEncoding;
ReadFinish(reader);
int n = RemainingHeaderBytes(reader);
if (n > 0)
{
reader.ReadBytes(n);
}
VerifyHeaderCrc(reader.GetCrc32());
}
private RarHeader ReadNextHeader(Stream stream)
{
FileHeader header4;
RarCryptoBinaryReader reader = new RarCryptoBinaryReader(stream, this.Password);
if (this.IsEncrypted)
{
if (this.Password == null)
{
throw new CryptographicException("Encrypted Rar archive has no password specified.");
}
reader.SkipQueue();
byte[] salt = reader.ReadBytes(8);
reader.InitializeAes(salt);
}
RarHeader header = RarHeader.Create(reader);
if (header == null)
{
return(null);
}
switch (header.HeaderType)
{
case HeaderType.MarkHeader:
return(header.PromoteHeader <MarkHeader>(reader));
case HeaderType.ArchiveHeader:
{
ArchiveHeader header2 = header.PromoteHeader <ArchiveHeader>(reader);
this.IsEncrypted = header2.HasPassword;
return(header2);
}
case HeaderType.FileHeader:
header4 = header.PromoteHeader <FileHeader>(reader);
switch (this.StreamingMode)
{
case SharpCompress.IO.StreamingMode.Streaming:
{
ReadOnlySubStream actualStream = new ReadOnlySubStream(reader.BaseStream, header4.CompressedSize);
if (header4.Salt == null)
{
header4.PackedStream = actualStream;
return(header4);
}
header4.PackedStream = new RarCryptoWrapper(actualStream, this.Password, header4.Salt);
return(header4);
}
case SharpCompress.IO.StreamingMode.Seekable:
{
header4.DataStartPosition = reader.BaseStream.Position;
Stream baseStream = reader.BaseStream;
baseStream.Position += header4.CompressedSize;
return(header4);
}
}
throw new InvalidFormatException("Invalid StreamingMode");
case HeaderType.ProtectHeader:
{
ProtectHeader header3 = header.PromoteHeader <ProtectHeader>(reader);
switch (this.StreamingMode)
{
case SharpCompress.IO.StreamingMode.Streaming:
Utility.Skip(reader.BaseStream, (long)header3.DataSize);
return(header3);
case SharpCompress.IO.StreamingMode.Seekable:
{
Stream stream1 = reader.BaseStream;
stream1.Position += header3.DataSize;
return(header3);
}
}
throw new InvalidFormatException("Invalid StreamingMode");
}
case HeaderType.NewSubHeader:
header4 = header.PromoteHeader <FileHeader>(reader);
switch (this.StreamingMode)
{
case SharpCompress.IO.StreamingMode.Streaming:
Utility.Skip(reader.BaseStream, header4.CompressedSize);
return(header4);
case SharpCompress.IO.StreamingMode.Seekable:
{
header4.DataStartPosition = reader.BaseStream.Position;
Stream stream3 = reader.BaseStream;
stream3.Position += header4.CompressedSize;
return(header4);
}
}
throw new InvalidFormatException("Invalid StreamingMode");
case HeaderType.EndArchiveHeader:
return(header.PromoteHeader <EndArchiveHeader>(reader));
}
throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType.ToString());
}
private RarHeader ReadNextHeader(Stream stream)
{
#if !NO_CRYPTO
var reader = new RarCryptoBinaryReader(stream, Options.Password);
if (IsEncrypted)
{
if (Options.Password == null)
{
throw new CryptographicException("Encrypted Rar archive has no password specified.");
}
reader.SkipQueue();
byte[] salt = reader.ReadBytes(8);
reader.InitializeAes(salt);
}
#else
var reader = new MarkingBinaryReader(stream);
#endif
RarHeader header = RarHeader.Create(reader);
if (header == null)
{
return(null);
}
switch (header.HeaderType)
{
case HeaderType.ArchiveHeader:
{
var ah = header.PromoteHeader <ArchiveHeader>(reader);
IsEncrypted = ah.HasPassword;
return(ah);
}
case HeaderType.MarkHeader:
{
return(header.PromoteHeader <MarkHeader>(reader));
}
case HeaderType.ProtectHeader:
{
ProtectHeader ph = header.PromoteHeader <ProtectHeader>(reader);
// skip the recovery record data, we do not use it.
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
reader.BaseStream.Position += ph.DataSize;
}
break;
case StreamingMode.Streaming:
{
reader.BaseStream.Skip(ph.DataSize);
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(ph);
}
case HeaderType.NewSubHeader:
{
FileHeader fh = header.PromoteHeader <FileHeader>(reader);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
//skip the data because it's useless?
reader.BaseStream.Skip(fh.CompressedSize);
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderType.FileHeader:
{
FileHeader fh = header.PromoteHeader <FileHeader>(reader);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
if (fh.Salt == null)
{
fh.PackedStream = ms;
}
else
{
#if !NO_CRYPTO
fh.PackedStream = new RarCryptoWrapper(ms, Options.Password, fh.Salt);
#else
throw new NotSupportedException("RarCrypto not supported");
#endif
}
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderType.EndArchiveHeader:
{
return(header.PromoteHeader <EndArchiveHeader>(reader));
}
default:
{
throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType);
}
}
}
public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
: base(header, reader, HeaderType.Archive)
{
}
public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
: base(header, reader, headerType)
{
}
public ArchiveCryptHeader(RarHeader header, RarCrcBinaryReader reader)
: base(header, reader, HeaderType.Crypt)
{
}
private RarHeader TryReadNextHeader(Stream stream)
{
RarCrcBinaryReader reader;
if (!IsEncrypted)
{
reader = new RarCrcBinaryReader(stream);
}
else
{
if (Options.Password == null)
{
throw new CryptographicException("Encrypted Rar archive has no password specified.");
}
reader = new RarCryptoBinaryReader(stream, Options.Password);
}
var header = RarHeader.TryReadBase(reader, _isRar5, Options.ArchiveEncoding);
if (header == null)
{
return(null);
}
switch (header.HeaderCode)
{
case HeaderCodeV.RAR5_ARCHIVE_HEADER:
case HeaderCodeV.RAR4_ARCHIVE_HEADER:
{
var ah = new ArchiveHeader(header, reader);
if (ah.IsEncrypted == true)
{
//!!! rar5 we don't know yet
IsEncrypted = true;
}
return(ah);
}
case HeaderCodeV.RAR4_PROTECT_HEADER:
{
var ph = new ProtectHeader(header, reader);
// skip the recovery record data, we do not use it.
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
reader.BaseStream.Position += ph.DataSize;
}
break;
case StreamingMode.Streaming:
{
reader.BaseStream.Skip(ph.DataSize);
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(ph);
}
case HeaderCodeV.RAR5_SERVICE_HEADER:
{
var fh = new FileHeader(header, reader, HeaderType.Service);
SkipData(fh, reader);
return(fh);
}
case HeaderCodeV.RAR4_NEW_SUB_HEADER:
{
var fh = new FileHeader(header, reader, HeaderType.NewSub);
SkipData(fh, reader);
return(fh);
}
case HeaderCodeV.RAR5_FILE_HEADER:
case HeaderCodeV.RAR4_FILE_HEADER:
{
var fh = new FileHeader(header, reader, HeaderType.File);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
if (fh.R4Salt == null)
{
fh.PackedStream = ms;
}
else
{
fh.PackedStream = new RarCryptoWrapper(ms, Options.Password, fh.R4Salt);
}
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderCodeV.RAR5_END_ARCHIVE_HEADER:
case HeaderCodeV.RAR4_END_ARCHIVE_HEADER:
{
return(new EndArchiveHeader(header, reader));
}
case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
{
var ch = new ArchiveCryptHeader(header, reader);
IsEncrypted = true;
return(ch);
}
default:
{
throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
}
}
}
private RarHeader ReadNextHeader(Stream stream)
{
MarkingBinaryReader reader = new MarkingBinaryReader(stream);
RarHeader header = RarHeader.Create(reader);
if (header == null)
{
return(null);
}
switch (header.HeaderType)
{
case HeaderType.ArchiveHeader:
{
return(header.PromoteHeader <ArchiveHeader>(reader));
}
case HeaderType.MarkHeader:
{
return(header.PromoteHeader <MarkHeader>(reader));
}
case HeaderType.NewSubHeader:
{
FileHeader fh = header.PromoteHeader <FileHeader>(reader);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
//skip the data because it's useless?
reader.BaseStream.Skip(fh.CompressedSize);
}
break;
default:
{
throw new InvalidRarFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderType.FileHeader:
{
FileHeader fh = header.PromoteHeader <FileHeader>(reader);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
ReadOnlySubStream ms
= new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize, false);
fh.PackedStream = ms;
}
break;
default:
{
throw new InvalidRarFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderType.EndArchiveHeader:
{
return(header.PromoteHeader <EndArchiveHeader>(reader));
}
default:
{
throw new InvalidRarFormatException("Invalid Rar Header: " + header.HeaderType.ToString());
}
}
}
private RarHeader TryReadNextHeader(Stream stream)
{
RarCrcBinaryReader reader;
if (!IsEncrypted)
{
reader = new RarCrcBinaryReader(stream);
}
else
{
#if !NO_CRYPTO
if (Options.Password == null)
{
throw new CryptographicException("Encrypted Rar archive has no password specified.");
}
reader = new RarCryptoBinaryReader(stream, Options.Password);
#else
throw new CryptographicException("Rar encryption unsupported on this platform");
#endif
}
var header = RarHeader.TryReadBase(reader, this.isRar5, Options.ArchiveEncoding);
if (header == null)
{
return(null);
}
switch (header.HeaderCode)
{
case HeaderCodeV.Rar5ArchiveHeader:
case HeaderCodeV.Rar4ArchiveHeader:
{
var ah = new ArchiveHeader(header, reader);
if (ah.IsEncrypted == true)
{
//!!! rar5 we don't know yet
IsEncrypted = true;
}
return(ah);
}
case HeaderCodeV.Rar4ProtectHeader:
{
var ph = new ProtectHeader(header, reader);
// skip the recovery record data, we do not use it.
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
reader.BaseStream.Position += ph.DataSize;
}
break;
case StreamingMode.Streaming:
{
reader.BaseStream.Skip(ph.DataSize);
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(ph);
}
case HeaderCodeV.Rar5ServiceHeader:
{
var fh = new FileHeader(header, reader, HeaderType.Service);
SkipData(fh, reader);
return(fh);
}
case HeaderCodeV.Rar4NewSubHeader:
{
var fh = new FileHeader(header, reader, HeaderType.NewSub);
SkipData(fh, reader);
return(fh);
}
case HeaderCodeV.Rar5FileHeader:
case HeaderCodeV.Rar4FileHeader:
{
var fh = new FileHeader(header, reader, HeaderType.File);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
if (fh.R4Salt == null)
{
fh.PackedStream = ms;
}
else
{
#if !NO_CRYPTO
fh.PackedStream = new RarCryptoWrapper(ms, Options.Password, fh.R4Salt);
#else
throw new NotSupportedException("RarCrypto not supported");
#endif
}
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderCodeV.Rar5EndArchiveHeader:
case HeaderCodeV.Rar4EndArchiveHeader:
{
return(new EndArchiveHeader(header, reader));
}
case HeaderCodeV.Rar5ArchiveEncryptionHeader:
{
var ch = new ArchiveCryptHeader(header, reader);
IsEncrypted = true;
return(ch);
}
default:
{
throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
}
}
}
private RarHeader ReadNextHeader(Stream stream)
{
#if PORTABLE
var reader = new MarkingBinaryReader(stream);
#else
var reader = new RarCryptoBinaryReader(stream, Password);
if (IsEncrypted)
{
reader.SkipQueue();
byte[] salt = reader.ReadBytes(8);
reader.InitializeAes(salt);
}
#endif
RarHeader header = RarHeader.Create(reader);
if (header == null)
{
return(null);
}
switch (header.HeaderType)
{
case HeaderType.ArchiveHeader:
{
var ah = header.PromoteHeader <ArchiveHeader>(reader);
IsEncrypted = ah.HasPassword;
return(ah);
}
case HeaderType.MarkHeader:
{
return(header.PromoteHeader <MarkHeader>(reader));
}
case HeaderType.NewSubHeader:
{
FileHeader fh = header.PromoteHeader <FileHeader>(reader);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
//skip the data because it's useless?
reader.BaseStream.Skip(fh.CompressedSize);
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderType.FileHeader:
{
FileHeader fh = header.PromoteHeader <FileHeader>(reader);
switch (StreamingMode)
{
case StreamingMode.Seekable:
{
fh.DataStartPosition = reader.BaseStream.Position;
reader.BaseStream.Position += fh.CompressedSize;
}
break;
case StreamingMode.Streaming:
{
var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
if (fh.Salt == null)
{
fh.PackedStream = ms;
}
else
{
#if PORTABLE
throw new NotSupportedException("Encrypted Rar files aren't supported in portable distro.");
#else
fh.PackedStream = new RarCryptoWrapper(ms, Password, fh.Salt);
#endif
}
}
break;
default:
{
throw new InvalidFormatException("Invalid StreamingMode");
}
}
return(fh);
}
case HeaderType.EndArchiveHeader:
{
return(header.PromoteHeader <EndArchiveHeader>(reader));
}
default:
{
throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType.ToString());
}
}
}