| private ProcessExtraData ( bool localHeader ) : void | ||
| localHeader | bool | True if the extra data fields should be handled /// for a local header, rather than for a central header. /// |
| return | void | |
/// <summary>
/// Search for and read the central directory of a zip file filling the entries array.
/// </summary>
/// <exception cref="System.IO.IOException">
/// An i/o error occurs.
/// </exception>
/// <exception cref="ICSharpCode.SharpZipLib.Zip.ZipException">
/// The central directory is malformed or cannot be found
/// </exception>
void ReadEntries()
{
// Search for the End Of Central Directory. When a zip comment is
// present the directory will start earlier
//
// The search is limited to 64K which is the maximum size of a trailing comment field to aid speed.
// This should be compatible with both SFX and ZIP files but has only been tested for Zip files
// If a SFX file has the Zip data attached as a resource and there are other resources occuring later then
// this could be invalid.
// Could also speed this up by reading memory in larger blocks.
if (baseStream_.CanSeek == false) {
throw new ZipException("ZipFile stream must be seekable");
}
long locatedEndOfCentralDir = LocateBlockWithSignature(ZipConstants.EndOfCentralDirectorySignature,
baseStream_.Length, ZipConstants.EndOfCentralRecordBaseSize, 0xffff);
if (locatedEndOfCentralDir < 0) {
throw new ZipException("Cannot find central directory");
}
// Read end of central directory record
ushort thisDiskNumber = ReadLEUshort();
ushort startCentralDirDisk = ReadLEUshort();
ulong entriesForThisDisk = ReadLEUshort();
ulong entriesForWholeCentralDir = ReadLEUshort();
ulong centralDirSize = ReadLEUint();
long offsetOfCentralDir = ReadLEUint();
uint commentSize = ReadLEUshort();
if ( commentSize > 0 ) {
byte[] comment = new byte[commentSize];
StreamUtils.ReadFully(baseStream_, comment);
comment_ = ZipConstants.ConvertToString(comment);
}
else {
comment_ = string.Empty;
}
bool isZip64 = false;
// Check if zip64 header information is required.
if ( (thisDiskNumber == 0xffff) ||
(startCentralDirDisk == 0xffff) ||
(entriesForThisDisk == 0xffff) ||
(entriesForWholeCentralDir == 0xffff) ||
(centralDirSize == 0xffffffff) ||
(offsetOfCentralDir == 0xffffffff) ) {
isZip64 = true;
long offset = LocateBlockWithSignature(ZipConstants.Zip64CentralDirLocatorSignature, locatedEndOfCentralDir, 0, 0x1000);
if ( offset < 0 ) {
throw new ZipException("Cannot find Zip64 locator");
}
// number of the disk with the start of the zip64 end of central directory 4 bytes
// relative offset of the zip64 end of central directory record 8 bytes
// total number of disks 4 bytes
ReadLEUint(); // startDisk64 is not currently used
ulong offset64 = ReadLEUlong();
uint totalDisks = ReadLEUint();
baseStream_.Position = (long)offset64;
long sig64 = ReadLEUint();
if ( sig64 != ZipConstants.Zip64CentralFileHeaderSignature ) {
throw new ZipException(string.Format("Invalid Zip64 Central directory signature at {0:X}", offset64));
}
// NOTE: Record size = SizeOfFixedFields + SizeOfVariableData - 12.
ulong recordSize = ReadLEUlong();
int versionMadeBy = ReadLEUshort();
int versionToExtract = ReadLEUshort();
uint thisDisk = ReadLEUint();
uint centralDirDisk = ReadLEUint();
entriesForThisDisk = ReadLEUlong();
entriesForWholeCentralDir = ReadLEUlong();
centralDirSize = ReadLEUlong();
offsetOfCentralDir = (long)ReadLEUlong();
// NOTE: zip64 extensible data sector (variable size) is ignored.
}
entries_ = new ZipEntry[entriesForThisDisk];
// SFX/embedded support, find the offset of the first entry vis the start of the stream
// This applies to Zip files that are appended to the end of an SFX stub.
// Or are appended as a resource to an executable.
// Zip files created by some archivers have the offsets altered to reflect the true offsets
// and so dont require any adjustment here...
// TODO: Difficulty with Zip64 and SFX offset handling needs resolution - maths?
if ( !isZip64 && (offsetOfCentralDir < locatedEndOfCentralDir - (4 + (long)centralDirSize)) ) {
offsetOfFirstEntry = locatedEndOfCentralDir - (4 + (long)centralDirSize + offsetOfCentralDir);
if (offsetOfFirstEntry <= 0) {
throw new ZipException("Invalid embedded zip archive");
}
}
baseStream_.Seek(offsetOfFirstEntry + offsetOfCentralDir, SeekOrigin.Begin);
for (ulong i = 0; i < entriesForThisDisk; i++) {
if (ReadLEUint() != ZipConstants.CentralHeaderSignature) {
throw new ZipException("Wrong Central Directory signature");
}
int versionMadeBy = ReadLEUshort();
int versionToExtract = ReadLEUshort();
int bitFlags = ReadLEUshort();
int method = ReadLEUshort();
uint dostime = ReadLEUint();
uint crc = ReadLEUint();
long csize = (long)ReadLEUint();
long size = (long)ReadLEUint();
int nameLen = ReadLEUshort();
int extraLen = ReadLEUshort();
int commentLen = ReadLEUshort();
int diskStartNo = ReadLEUshort(); // Not currently used
int internalAttributes = ReadLEUshort(); // Not currently used
uint externalAttributes = ReadLEUint();
long offset = ReadLEUint();
byte[] buffer = new byte[Math.Max(nameLen, commentLen)];
StreamUtils.ReadFully(baseStream_, buffer, 0, nameLen);
string name = ZipConstants.ConvertToStringExt(bitFlags, buffer, nameLen);
ZipEntry entry = new ZipEntry(name, versionToExtract, versionMadeBy, (CompressionMethod)method);
entry.Crc = crc & 0xffffffffL;
entry.Size = size & 0xffffffffL;
entry.CompressedSize = csize & 0xffffffffL;
entry.Flags = bitFlags;
entry.DosTime = (uint)dostime;
entry.ZipFileIndex = (long)i;
entry.Offset = offset;
entry.ExternalFileAttributes = (int)externalAttributes;
if ((bitFlags & 8) == 0) {
entry.CryptoCheckValue = (byte)(crc >> 24);
}
else {
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
if (extraLen > 0) {
byte[] extra = new byte[extraLen];
StreamUtils.ReadFully(baseStream_, extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(false);
if (commentLen > 0) {
StreamUtils.ReadFully(baseStream_, buffer, 0, commentLen);
entry.Comment = ZipConstants.ConvertToStringExt(bitFlags, buffer, commentLen);
}
entries_[i] = entry;
}
}
/// <summary>
/// Advances to the next entry in the archive
/// </summary>
/// <returns>
/// The next <see cref="ZipEntry">entry</see> in the archive or null if there are no more entries.
/// </returns>
/// <remarks>
/// If the previous entry is still open <see cref="CloseEntry">CloseEntry</see> is called.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// Input stream is closed
/// </exception>
/// <exception cref="ZipException">
/// Password is not set, password is invalid, compression method is invalid,
/// version required to extract is not supported
/// </exception>
public ZipEntry GetNextEntry()
{
if (crc == null) {
throw new InvalidOperationException("Closed.");
}
if (entry != null) {
CloseEntry();
}
int header = inputBuffer.ReadLeInt();
if (header == ZipConstants.CentralHeaderSignature ||
header == ZipConstants.EndOfCentralDirectorySignature ||
header == ZipConstants.CentralHeaderDigitalSignature ||
header == ZipConstants.ArchiveExtraDataSignature ||
header == ZipConstants.Zip64CentralFileHeaderSignature) {
// No more individual entries exist
Close();
return null;
}
// -jr- 07-Dec-2003 Ignore spanning temporary signatures if found
// Spanning signature is same as descriptor signature and is untested as yet.
if ( (header == ZipConstants.SpanningTempSignature) || (header == ZipConstants.SpanningSignature) ) {
header = inputBuffer.ReadLeInt();
}
if (header != ZipConstants.LocalHeaderSignature) {
throw new ZipException("Wrong Local header signature: 0x" + String.Format("{0:X}", header));
}
short versionRequiredToExtract = (short)inputBuffer.ReadLeShort();
flags = inputBuffer.ReadLeShort();
method = inputBuffer.ReadLeShort();
uint dostime = (uint)inputBuffer.ReadLeInt();
int crc2 = inputBuffer.ReadLeInt();
csize = inputBuffer.ReadLeInt();
size = inputBuffer.ReadLeInt();
int nameLen = inputBuffer.ReadLeShort();
int extraLen = inputBuffer.ReadLeShort();
bool isCrypted = (flags & 1) == 1;
byte[] buffer = new byte[nameLen];
inputBuffer.ReadRawBuffer(buffer);
string name = ZipConstants.ConvertToStringExt(flags, buffer);
entry = new ZipEntry(name, versionRequiredToExtract);
entry.Flags = flags;
entry.CompressionMethod = (CompressionMethod)method;
if ((flags & 8) == 0) {
entry.Crc = crc2 & 0xFFFFFFFFL;
entry.Size = size & 0xFFFFFFFFL;
entry.CompressedSize = csize & 0xFFFFFFFFL;
entry.CryptoCheckValue = (byte)((crc2 >> 24) & 0xff);
} else {
// This allows for GNU, WinZip and possibly other archives, the PKZIP spec
// says these values are zero under these circumstances.
if (crc2 != 0) {
entry.Crc = crc2 & 0xFFFFFFFFL;
}
if (size != 0) {
entry.Size = size & 0xFFFFFFFFL;
}
if (csize != 0) {
entry.CompressedSize = csize & 0xFFFFFFFFL;
}
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
entry.DosTime = dostime;
// If local header requires Zip64 is true then the extended header should contain
// both values.
// Handle extra data if present. This can set/alter some fields of the entry.
if (extraLen > 0) {
byte[] extra = new byte[extraLen];
inputBuffer.ReadRawBuffer(extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(true);
if ( entry.CompressedSize >= 0 ) {
csize = entry.CompressedSize;
}
if ( entry.Size >= 0 ) {
size = entry.Size;
}
if (method == (int)CompressionMethod.Stored && (!isCrypted && csize != size || (isCrypted && csize - ZipConstants.CryptoHeaderSize != size))) {
throw new ZipException("Stored, but compressed != uncompressed");
}
// Determine how to handle reading of data if this is attempted.
if (entry.IsCompressionMethodSupported()) {
internalReader = new ReadDataHandler(InitialRead);
} else {
internalReader = new ReadDataHandler(ReadingNotSupported);
}
return entry;
}
/// <summary>
/// Advances to the next entry in the archive
/// </summary>
/// <returns>
/// The next <see cref="ZipEntry">entry</see> in the archive or null if there are no more entries.
/// </returns>
/// <remarks>
/// If the previous entry is still open <see cref="CloseEntry">CloseEntry</see> is called.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// Input stream is closed
/// </exception>
/// <exception cref="ZipException">
/// Password is not set, password is invalid, compression method is invalid,
/// version required to extract is not supported
/// </exception>
public ZipEntry GetNextEntry()
{
if (crc == null)
{
throw new InvalidOperationException("Closed.");
}
if (entry != null)
{
CloseEntry();
}
int header = inputBuffer.ReadLeInt();
if (header == ZipConstants.CentralHeaderSignature ||
header == ZipConstants.EndOfCentralDirectorySignature ||
header == ZipConstants.CentralHeaderDigitalSignature ||
header == ZipConstants.ArchiveExtraDataSignature ||
header == ZipConstants.Zip64CentralFileHeaderSignature)
{
// No more individual entries exist
#if NET45
Close();
#endif
#if NETSTANDARD1_3
Dispose();
#endif
return(null);
}
// -jr- 07-Dec-2003 Ignore spanning temporary signatures if found
// Spanning signature is same as descriptor signature and is untested as yet.
if ((header == ZipConstants.SpanningTempSignature) || (header == ZipConstants.SpanningSignature))
{
header = inputBuffer.ReadLeInt();
}
if (header != ZipConstants.LocalHeaderSignature)
{
throw new ZipException("Wrong Local header signature: 0x" + String.Format("{0:X}", header));
}
var versionRequiredToExtract = (short)inputBuffer.ReadLeShort();
flags = inputBuffer.ReadLeShort();
method = inputBuffer.ReadLeShort();
var dostime = (uint)inputBuffer.ReadLeInt();
int crc2 = inputBuffer.ReadLeInt();
csize = inputBuffer.ReadLeInt();
size = inputBuffer.ReadLeInt();
int nameLen = inputBuffer.ReadLeShort();
int extraLen = inputBuffer.ReadLeShort();
bool isCrypted = (flags & 1) == 1;
byte[] buffer = new byte[nameLen];
inputBuffer.ReadRawBuffer(buffer);
string name = ZipConstants.ConvertToStringExt(flags, buffer);
entry = new ZipEntry(name, versionRequiredToExtract);
entry.Flags = flags;
entry.CompressionMethod = (CompressionMethod)method;
if ((flags & 8) == 0)
{
entry.Crc = crc2 & 0xFFFFFFFFL;
entry.Size = size & 0xFFFFFFFFL;
entry.CompressedSize = csize & 0xFFFFFFFFL;
entry.CryptoCheckValue = (byte)((crc2 >> 24) & 0xff);
}
else
{
// This allows for GNU, WinZip and possibly other archives, the PKZIP spec
// says these values are zero under these circumstances.
if (crc2 != 0)
{
entry.Crc = crc2 & 0xFFFFFFFFL;
}
if (size != 0)
{
entry.Size = size & 0xFFFFFFFFL;
}
if (csize != 0)
{
entry.CompressedSize = csize & 0xFFFFFFFFL;
}
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
entry.DosTime = dostime;
// If local header requires Zip64 is true then the extended header should contain
// both values.
// Handle extra data if present. This can set/alter some fields of the entry.
if (extraLen > 0)
{
byte[] extra = new byte[extraLen];
inputBuffer.ReadRawBuffer(extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(true);
if (entry.CompressedSize >= 0)
{
csize = entry.CompressedSize;
}
if (entry.Size >= 0)
{
size = entry.Size;
}
if (method == (int)CompressionMethod.Stored && (!isCrypted && csize != size || (isCrypted && csize - ZipConstants.CryptoHeaderSize != size)))
{
throw new ZipException("Stored, but compressed != uncompressed");
}
// Determine how to handle reading of data if this is attempted.
if (entry.IsCompressionMethodSupported())
{
internalReader = new ReadDataHandler(InitialRead);
}
else
{
internalReader = new ReadDataHandler(ReadingNotSupported);
}
return(entry);
}
public ZipEntry GetNextEntry()
{
if (crc == null) {
throw new InvalidOperationException("Closed.");
}
if (entry != null) {
CloseEntry();
}
int header = inputBuffer.ReadLeInt();
if (header == ZipConstants.CentralHeaderSignature ||
header == ZipConstants.EndOfCentralDirectorySignature ||
header == ZipConstants.CentralHeaderDigitalSignature ||
header == ZipConstants.ArchiveExtraDataSignature ||
header == ZipConstants.Zip64CentralFileHeaderSignature) {
Close();
return null;
}
if ( (header == ZipConstants.SpanningTempSignature) || (header == ZipConstants.SpanningSignature) ) {
header = inputBuffer.ReadLeInt();
}
if (header != ZipConstants.LocalHeaderSignature) {
throw new ZipException("Wrong Local header signature: 0x" + String.Format("{0:X}", header));
}
short versionRequiredToExtract = (short)inputBuffer.ReadLeShort();
flags = inputBuffer.ReadLeShort();
method = inputBuffer.ReadLeShort();
uint dostime = (uint)inputBuffer.ReadLeInt();
int crc2 = inputBuffer.ReadLeInt();
csize = inputBuffer.ReadLeInt();
size = inputBuffer.ReadLeInt();
int nameLen = inputBuffer.ReadLeShort();
int extraLen = inputBuffer.ReadLeShort();
bool isCrypted = (flags & 1) == 1;
byte[] buffer = new byte[nameLen];
inputBuffer.ReadRawBuffer(buffer);
string name = ZipConstants.ConvertToStringExt(flags, buffer);
entry = new ZipEntry(name, versionRequiredToExtract);
entry.Flags = flags;
entry.CompressionMethod = (CompressionMethod)method;
if ((flags & 8) == 0) {
entry.Crc = crc2 & 0xFFFFFFFFL;
entry.Size = size & 0xFFFFFFFFL;
entry.CompressedSize = csize & 0xFFFFFFFFL;
entry.CryptoCheckValue = (byte)((crc2 >> 24) & 0xff);
} else {
if (crc2 != 0) {
entry.Crc = crc2 & 0xFFFFFFFFL;
}
if (size != 0) {
entry.Size = size & 0xFFFFFFFFL;
}
if (csize != 0) {
entry.CompressedSize = csize & 0xFFFFFFFFL;
}
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
entry.DosTime = dostime;
if (extraLen > 0) {
byte[] extra = new byte[extraLen];
inputBuffer.ReadRawBuffer(extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(true);
if ( entry.CompressedSize >= 0 ) {
csize = entry.CompressedSize;
}
if ( entry.Size >= 0 ) {
size = entry.Size;
}
if (method == (int)CompressionMethod.Stored && (!isCrypted && csize != size || (isCrypted && csize - ZipConstants.CryptoHeaderSize != size))) {
throw new ZipException("Stored, but compressed != uncompressed");
}
if (entry.IsCompressionMethodSupported()) {
internalReader = new ReadDataHandler(InitialRead);
} else {
internalReader = new ReadDataHandler(ReadingNotSupported);
}
return entry;
}
public ZipEntry GetNextEntry()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
if (crc == null)
{
throw new InvalidOperationException("Closed.");
}
if (entry != null)
{
CloseEntry();
}
int num = inputBuffer.ReadLeInt();
switch (num)
{
case 33639248:
case 84233040:
case 101010256:
case 101075792:
case 117853008:
((Stream)this).Close();
return(null);
case 134695760:
case 808471376:
num = inputBuffer.ReadLeInt();
break;
}
if (num != 67324752)
{
throw new ZipException("Wrong Local header signature: 0x" + $"{num:X}");
}
short versionRequiredToExtract = (short)inputBuffer.ReadLeShort();
flags = inputBuffer.ReadLeShort();
method = inputBuffer.ReadLeShort();
uint num2 = (uint)inputBuffer.ReadLeInt();
int num3 = inputBuffer.ReadLeInt();
csize = inputBuffer.ReadLeInt();
size = inputBuffer.ReadLeInt();
int num4 = inputBuffer.ReadLeShort();
int num5 = inputBuffer.ReadLeShort();
bool flag = (flags & 1) == 1;
byte[] array = new byte[num4];
inputBuffer.ReadRawBuffer(array);
string name = ZipConstants.ConvertToStringExt(flags, array);
entry = new ZipEntry(name, versionRequiredToExtract);
entry.Flags = flags;
entry.CompressionMethod = (CompressionMethod)method;
if ((flags & 8) == 0)
{
entry.Crc = num3 & 0xFFFFFFFFu;
entry.Size = size & 0xFFFFFFFFu;
entry.CompressedSize = csize & 0xFFFFFFFFu;
entry.CryptoCheckValue = (byte)((uint)(num3 >> 24) & 0xFFu);
}
else
{
if (num3 != 0)
{
entry.Crc = num3 & 0xFFFFFFFFu;
}
if (size != 0)
{
entry.Size = size & 0xFFFFFFFFu;
}
if (csize != 0)
{
entry.CompressedSize = csize & 0xFFFFFFFFu;
}
entry.CryptoCheckValue = (byte)((num2 >> 8) & 0xFFu);
}
entry.DosTime = num2;
if (num5 > 0)
{
byte[] array2 = new byte[num5];
inputBuffer.ReadRawBuffer(array2);
entry.ExtraData = array2;
}
entry.ProcessExtraData(localHeader: true);
if (entry.CompressedSize >= 0)
{
csize = entry.CompressedSize;
}
if (entry.Size >= 0)
{
size = entry.Size;
}
if (method == 0 && ((!flag && csize != size) || (flag && csize - 12 != size)))
{
throw new ZipException("Stored, but compressed != uncompressed");
}
if (entry.IsCompressionMethodSupported())
{
internalReader = InitialRead;
}
else
{
internalReader = ReadingNotSupported;
}
return(entry);
}
public ZipEntry GetNextEntry()
{
if (crc == null)
{
throw new InvalidOperationException("Closed.");
}
if (entry != null)
{
CloseEntry();
}
int header = inputBuffer.ReadLeInt();
if (header == ZipConstants.CentralHeaderSignature ||
header == ZipConstants.EndOfCentralDirectorySignature ||
header == ZipConstants.CentralHeaderDigitalSignature ||
header == ZipConstants.ArchiveExtraDataSignature ||
header == ZipConstants.Zip64CentralFileHeaderSignature)
{
Close();
return(null);
}
if ((header == ZipConstants.SpanningTempSignature) || (header == ZipConstants.SpanningSignature))
{
header = inputBuffer.ReadLeInt();
}
if (header != ZipConstants.LocalHeaderSignature)
{
throw new ZipException("Wrong Local header signature: 0x" + String.Format("{0:X}", header));
}
short versionRequiredToExtract = (short)inputBuffer.ReadLeShort();
flags = inputBuffer.ReadLeShort();
method = inputBuffer.ReadLeShort();
uint dostime = (uint)inputBuffer.ReadLeInt();
int crc2 = inputBuffer.ReadLeInt();
csize = inputBuffer.ReadLeInt();
size = inputBuffer.ReadLeInt();
int nameLen = inputBuffer.ReadLeShort();
int extraLen = inputBuffer.ReadLeShort();
bool isCrypted = (flags & 1) == 1;
byte[] buffer = new byte[nameLen];
inputBuffer.ReadRawBuffer(buffer);
string name = ZipConstants.ConvertToStringExt(flags, buffer);
entry = new ZipEntry(name, versionRequiredToExtract);
entry.Flags = flags;
entry.CompressionMethod = (CompressionMethod)method;
if ((flags & 8) == 0)
{
entry.Crc = crc2 & 0xFFFFFFFFL;
entry.Size = size & 0xFFFFFFFFL;
entry.CompressedSize = csize & 0xFFFFFFFFL;
entry.CryptoCheckValue = (byte)((crc2 >> 24) & 0xff);
}
else
{
if (crc2 != 0)
{
entry.Crc = crc2 & 0xFFFFFFFFL;
}
if (size != 0)
{
entry.Size = size & 0xFFFFFFFFL;
}
if (csize != 0)
{
entry.CompressedSize = csize & 0xFFFFFFFFL;
}
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
entry.DosTime = dostime;
if (extraLen > 0)
{
byte[] extra = new byte[extraLen];
inputBuffer.ReadRawBuffer(extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(true);
if (entry.CompressedSize >= 0)
{
csize = entry.CompressedSize;
}
if (entry.Size >= 0)
{
size = entry.Size;
}
if (method == (int)CompressionMethod.Stored && (!isCrypted && csize != size || (isCrypted && csize - ZipConstants.CryptoHeaderSize != size)))
{
throw new ZipException("Stored, but compressed != uncompressed");
}
if (entry.IsCompressionMethodSupported())
{
internalReader = new ReadDataHandler(InitialRead);
}
else
{
internalReader = new ReadDataHandler(ReadingNotSupported);
}
return(entry);
}
void ReadEntries()
{
if (baseStream_.CanSeek == false) {
throw new ZipException("ZipFile stream must be seekable");
}
long locatedEndOfCentralDir = LocateBlockWithSignature(ZipConstants.EndOfCentralDirectorySignature,
baseStream_.Length, ZipConstants.EndOfCentralRecordBaseSize, 0xffff);
if (locatedEndOfCentralDir < 0) {
throw new ZipException("Cannot find central directory");
}
ushort thisDiskNumber = ReadLEUshort();
ushort startCentralDirDisk = ReadLEUshort();
ulong entriesForThisDisk = ReadLEUshort();
ulong entriesForWholeCentralDir = ReadLEUshort();
ulong centralDirSize = ReadLEUint();
long offsetOfCentralDir = ReadLEUint();
uint commentSize = ReadLEUshort();
if ( commentSize > 0 ) {
byte[] comment = new byte[commentSize];
StreamUtils.ReadFully(baseStream_, comment);
comment_ = ZipConstants.ConvertToString(comment);
}
else {
comment_ = string.Empty;
}
bool isZip64 = false;
if ( (thisDiskNumber == 0xffff) ||
(startCentralDirDisk == 0xffff) ||
(entriesForThisDisk == 0xffff) ||
(entriesForWholeCentralDir == 0xffff) ||
(centralDirSize == 0xffffffff) ||
(offsetOfCentralDir == 0xffffffff) ) {
isZip64 = true;
long offset = LocateBlockWithSignature(ZipConstants.Zip64CentralDirLocatorSignature, locatedEndOfCentralDir, 0, 0x1000);
if ( offset < 0 ) {
throw new ZipException("Cannot find Zip64 locator");
}
ReadLEUint();
ulong offset64 = ReadLEUlong();
uint totalDisks = ReadLEUint();
baseStream_.Position = (long)offset64;
long sig64 = ReadLEUint();
if ( sig64 != ZipConstants.Zip64CentralFileHeaderSignature ) {
throw new ZipException(string.Format("Invalid Zip64 Central directory signature at {0:X}", offset64));
}
ulong recordSize = ( ulong )ReadLEUlong();
int versionMadeBy = ReadLEUshort();
int versionToExtract = ReadLEUshort();
uint thisDisk = ReadLEUint();
uint centralDirDisk = ReadLEUint();
entriesForThisDisk = ReadLEUlong();
entriesForWholeCentralDir = ReadLEUlong();
centralDirSize = ReadLEUlong();
offsetOfCentralDir = (long)ReadLEUlong();
}
entries_ = new ZipEntry[entriesForThisDisk];
if ( !isZip64 && (offsetOfCentralDir < locatedEndOfCentralDir - (4 + (long)centralDirSize)) ) {
offsetOfFirstEntry = locatedEndOfCentralDir - (4 + (long)centralDirSize + offsetOfCentralDir);
if (offsetOfFirstEntry <= 0) {
throw new ZipException("Invalid embedded zip archive");
}
}
baseStream_.Seek(offsetOfFirstEntry + offsetOfCentralDir, SeekOrigin.Begin);
for (ulong i = 0; i < entriesForThisDisk; i++) {
if (ReadLEUint() != ZipConstants.CentralHeaderSignature) {
throw new ZipException("Wrong Central Directory signature");
}
int versionMadeBy = ReadLEUshort();
int versionToExtract = ReadLEUshort();
int bitFlags = ReadLEUshort();
int method = ReadLEUshort();
uint dostime = ReadLEUint();
uint crc = ReadLEUint();
long csize = (long)ReadLEUint();
long size = (long)ReadLEUint();
int nameLen = ReadLEUshort();
int extraLen = ReadLEUshort();
int commentLen = ReadLEUshort();
int diskStartNo = ReadLEUshort();
int internalAttributes = ReadLEUshort();
uint externalAttributes = ReadLEUint();
long offset = ReadLEUint();
byte[] buffer = new byte[Math.Max(nameLen, commentLen)];
StreamUtils.ReadFully(baseStream_, buffer, 0, nameLen);
string name = ZipConstants.ConvertToStringExt(bitFlags, buffer, nameLen);
ZipEntry entry = new ZipEntry(name, versionToExtract, versionMadeBy, (CompressionMethod)method);
entry.Crc = crc & 0xffffffffL;
entry.Size = size & 0xffffffffL;
entry.CompressedSize = csize & 0xffffffffL;
entry.Flags = bitFlags;
entry.DosTime = (uint)dostime;
entry.ZipFileIndex = (long)i;
entry.Offset = offset;
entry.ExternalFileAttributes = (int)externalAttributes;
if ((bitFlags & 8) == 0) {
entry.CryptoCheckValue = (byte)(crc >> 24);
}
else {
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
if (extraLen > 0) {
byte[] extra = new byte[extraLen];
StreamUtils.ReadFully(baseStream_, extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(false);
if (commentLen > 0) {
StreamUtils.ReadFully(baseStream_, buffer, 0, commentLen);
entry.Comment = ZipConstants.ConvertToStringExt(bitFlags, buffer, commentLen);
}
entries_[i] = entry;
}
}
private void ReadEntries()
{
if (!this.baseStream_.CanSeek)
{
throw new ZipException("ZipFile stream must be seekable");
}
long endLocation = this.LocateBlockWithSignature(0x6054b50, this.baseStream_.Length, 0x16, 0xffff);
if (endLocation < 0L)
{
throw new ZipException("Cannot find central directory");
}
ushort num2 = this.ReadLEUshort();
ushort num3 = this.ReadLEUshort();
ulong num4 = this.ReadLEUshort();
ulong num5 = this.ReadLEUshort();
ulong num6 = this.ReadLEUint();
long num7 = this.ReadLEUint();
uint num8 = this.ReadLEUshort();
if (num8 > 0)
{
byte[] buffer = new byte[num8];
StreamUtils.ReadFully(this.baseStream_, buffer);
this.comment_ = ZipConstants.ConvertToString(buffer);
}
else
{
this.comment_ = string.Empty;
}
bool flag = false;
if ((((num2 == 0xffff) || (num3 == 0xffff)) || ((num4 == 0xffffL) || (num5 == 0xffffL))) || ((num6 == 0xffffffffL) || (num7 == 0xffffffffL)))
{
flag = true;
if (this.LocateBlockWithSignature(0x7064b50, endLocation, 0, 0x1000) < 0L)
{
throw new ZipException("Cannot find Zip64 locator");
}
this.ReadLEUint();
ulong num10 = this.ReadLEUlong();
this.ReadLEUint();
this.baseStream_.Position = (long) num10;
long num11 = this.ReadLEUint();
if (num11 != 0x6064b50L)
{
throw new ZipException(string.Format("Invalid Zip64 Central directory signature at {0:X}", num10));
}
this.ReadLEUlong();
this.ReadLEUshort();
this.ReadLEUshort();
this.ReadLEUint();
this.ReadLEUint();
num4 = this.ReadLEUlong();
num5 = this.ReadLEUlong();
num6 = this.ReadLEUlong();
num7 = (long) this.ReadLEUlong();
}
this.entries_ = new ZipEntry[num4];
if (!flag && (num7 < (((ulong) endLocation) - (((ulong) 4L) + num6))))
{
this.offsetOfFirstEntry = endLocation - ((4L + ((long) num6)) + num7);
if (this.offsetOfFirstEntry <= 0L)
{
throw new ZipException("Invalid embedded zip archive");
}
}
this.baseStream_.Seek(this.offsetOfFirstEntry + num7, SeekOrigin.Begin);
for (ulong i = 0L; i < num4; i += (ulong) 1L)
{
if (this.ReadLEUint() != 0x2014b50)
{
throw new ZipException("Wrong Central Directory signature");
}
int madeByInfo = this.ReadLEUshort();
int versionRequiredToExtract = this.ReadLEUshort();
int flags = this.ReadLEUshort();
int num16 = this.ReadLEUshort();
uint num17 = this.ReadLEUint();
uint num18 = this.ReadLEUint();
long num19 = this.ReadLEUint();
long num20 = this.ReadLEUint();
int num21 = this.ReadLEUshort();
int num22 = this.ReadLEUshort();
int num23 = this.ReadLEUshort();
this.ReadLEUshort();
this.ReadLEUshort();
uint num24 = this.ReadLEUint();
long num25 = this.ReadLEUint();
byte[] buffer2 = new byte[Math.Max(num21, num23)];
StreamUtils.ReadFully(this.baseStream_, buffer2, 0, num21);
ZipEntry entry = new ZipEntry(ZipConstants.ConvertToStringExt(flags, buffer2, num21), versionRequiredToExtract, madeByInfo, (CompressionMethod) num16) {
Crc = (long) (num18 & 0xffffffffL),
Size = num20 & ((long) 0xffffffffL),
CompressedSize = num19 & ((long) 0xffffffffL),
Flags = flags,
DosTime = (long) num17,
ZipFileIndex = (long) i,
Offset = num25,
ExternalFileAttributes = (int) num24
};
if ((flags & 8) == 0)
{
entry.CryptoCheckValue = (byte) (num18 >> 0x18);
}
else
{
entry.CryptoCheckValue = (byte) ((num17 >> 8) & 0xff);
}
if (num22 > 0)
{
byte[] buffer3 = new byte[num22];
StreamUtils.ReadFully(this.baseStream_, buffer3);
entry.ExtraData = buffer3;
}
entry.ProcessExtraData(false);
if (num23 > 0)
{
StreamUtils.ReadFully(this.baseStream_, buffer2, 0, num23);
entry.Comment = ZipConstants.ConvertToStringExt(flags, buffer2, num23);
}
this.entries_[(int) ((IntPtr) i)] = entry;
}
}