using System;

using System.Collections;

using System.IO;

using System.Text;

using System.Globalization;

using System.Security.Cryptography;

using ICSharpCode.SharpZipLib.Encryption;

using ICSharpCode.SharpZipLib.Core;

using ICSharpCode.SharpZipLib.Checksum;

using ICSharpCode.SharpZipLib.Zip.Compression.Streams;

using ICSharpCode.SharpZipLib.Zip.Compression;

namespace ICSharpCode.SharpZipLib.Zip

{

#region Keys Required Event Args

/// <summary>

/// Arguments used with KeysRequiredEvent

/// </summary>

public class KeysRequiredEventArgs : EventArgs

{

#region Constructors

/// <summary>

/// Initialise a new instance of <see cref="KeysRequiredEventArgs"></see>

/// </summary>

/// <param name="name">The name of the file for which keys are required.</param>

public KeysRequiredEventArgs(string name)

{

fileName = name;

}

/// <summary>

/// Initialise a new instance of <see cref="KeysRequiredEventArgs"></see>

/// </summary>

/// <param name="name">The name of the file for which keys are required.</param>

/// <param name="keyValue">The current key value.</param>

public KeysRequiredEventArgs(string name, byte[] keyValue)

{

fileName = name;

key = keyValue;

}

#endregion

#region Properties

/// <summary>

/// Gets the name of the file for which keys are required.

/// </summary>

public string FileName {

get { return fileName; }

}

/// <summary>

/// Gets or sets the key value

/// </summary>

public byte[] Key {

get { return key; }

set { key = value; }

}

#endregion

#region Instance Fields

string fileName;

byte[] key;

#endregion

}

#endregion

#region Test Definitions

/// <summary>

/// The strategy to apply to testing.

/// </summary>

public enum TestStrategy

{

/// <summary>

/// Find the first error only.

/// </summary>

FindFirstError,

/// <summary>

/// Find all possible errors.

/// </summary>

FindAllErrors,

}

/// <summary>

/// The operation in progress reported by a <see cref="ZipTestResultHandler"/> during testing.

/// </summary>

/// <seealso cref="ZipFile.TestArchive(bool)">TestArchive</seealso>

public enum TestOperation

{

/// <summary>

/// Setting up testing.

/// </summary>

Initialising,

/// <summary>

/// Testing an individual entries header

/// </summary>

EntryHeader,

/// <summary>

/// Testing an individual entries data

/// </summary>

EntryData,

/// <summary>

/// Testing an individual entry has completed.

/// </summary>

EntryComplete,

/// <summary>

/// Running miscellaneous tests

/// </summary>

MiscellaneousTests,

/// <summary>

/// Testing is complete

/// </summary>

Complete,

}

/// <summary>

/// Status returned returned by <see cref="ZipTestResultHandler"/> during testing.

/// </summary>

/// <seealso cref="ZipFile.TestArchive(bool)">TestArchive</seealso>

public class TestStatus

{

#region Constructors

/// <summary>

/// Initialise a new instance of <see cref="TestStatus"/>

/// </summary>

/// <param name="file">The <see cref="ZipFile"/> this status applies to.</param>

public TestStatus(ZipFile file)

{

file_ = file;

}

#endregion

#region Properties

/// <summary>

/// Get the current <see cref="TestOperation"/> in progress.

/// </summary>

public TestOperation Operation {

get { return operation_; }

}

/// <summary>

/// Get the <see cref="ZipFile"/> this status is applicable to.

/// </summary>

public ZipFile File {

get { return file_; }

}

/// <summary>

/// Get the current/last entry tested.

/// </summary>

public ZipEntry Entry {

get { return entry_; }

}

/// <summary>

/// Get the number of errors detected so far.

/// </summary>

public int ErrorCount {

get { return errorCount_; }

}

/// <summary>

/// Get the number of bytes tested so far for the current entry.

/// </summary>

public long BytesTested {

get { return bytesTested_; }

}

/// <summary>

/// Get a value indicating wether the last entry test was valid.

/// </summary>

public bool EntryValid {

get { return entryValid_; }

}

#endregion

#region Internal API

internal void AddError()

{

errorCount_++;

entryValid_ = false;

}

internal void SetOperation(TestOperation operation)

{

operation_ = operation;

}

internal void SetEntry(ZipEntry entry)

{

entry_ = entry;

entryValid_ = true;

bytesTested_ = 0;

}

internal void SetBytesTested(long value)

{

bytesTested_ = value;

}

#endregion

#region Instance Fields

ZipFile file_;

ZipEntry entry_;

bool entryValid_;

int errorCount_;

long bytesTested_;

TestOperation operation_;

#endregion

}

/// <summary>

/// Delegate invoked during <see cref="ZipFile.TestArchive(bool, TestStrategy, ZipTestResultHandler)">testing</see> if supplied indicating current progress and status.

/// </summary>

/// <remarks>If the message is non-null an error has occured. If the message is null

/// the operation as found in <see cref="TestStatus">status</see> has started.</remarks>

public delegate void ZipTestResultHandler(TestStatus status, string message);

#endregion

#region Update Definitions

/// <summary>

/// The possible ways of <see cref="ZipFile.CommitUpdate()">applying updates</see> to an archive.

/// </summary>

public enum FileUpdateMode

{

/// <summary>

/// Perform all updates on temporary files ensuring that the original file is saved.

/// </summary>

Safe,

/// <summary>

/// Update the archive directly, which is faster but less safe.

/// </summary>

Direct,

}

#endregion

#region ZipFile Class

/// <summary>

/// This class represents a Zip archive. You can ask for the contained

/// entries, or get an input stream for a file entry. The entry is

/// automatically decompressed.

///

/// You can also update the archive adding or deleting entries.

///

/// This class is thread safe for input: You can open input streams for arbitrary

/// entries in different threads.

/// <br/>

/// <br/>Author of the original java version : Jochen Hoenicke

/// </summary>

/// <example>

/// <code>

/// using System;

/// using System.Text;

/// using System.Collections;

/// using System.IO;

///

/// using ICSharpCode.SharpZipLib.Zip;

///

/// class MainClass

/// {

/// static public void Main(string[] args)

/// {

/// using (ZipFile zFile = new ZipFile(args[0])) {

/// Console.WriteLine("Listing of : " + zFile.Name);

/// Console.WriteLine("");

/// Console.WriteLine("Raw Size Size Date Time Name");

/// Console.WriteLine("-------- -------- -------- ------ ---------");

/// foreach (ZipEntry e in zFile) {

/// if ( e.IsFile ) {

/// DateTime d = e.DateTime;

/// Console.WriteLine("{0, -10}{1, -10}{2} {3} {4}", e.Size, e.CompressedSize,

/// d.ToString("dd-MM-yy"), d.ToString("HH:mm"),

/// e.Name);

/// }

/// }

/// }

/// }

/// }

/// </code>

/// </example>

public class ZipFile : IEnumerable, IDisposable

{

#region KeyHandling

/// <summary>

/// Delegate for handling keys/password setting during compresion/decompression.

/// </summary>

public delegate void KeysRequiredEventHandler(

object sender,

KeysRequiredEventArgs e

);

/// <summary>

/// Event handler for handling encryption keys.

/// </summary>

public KeysRequiredEventHandler KeysRequired;

/// <summary>

/// Handles getting of encryption keys when required.

/// </summary>

/// <param name="fileName">The file for which encryption keys are required.</param>

void OnKeysRequired(string fileName)

{

if (KeysRequired != null) {

var krea = new KeysRequiredEventArgs(fileName, key);

KeysRequired(this, krea);

key = krea.Key;

}

}

/// <summary>

/// Get/set the encryption key value.

/// </summary>

byte[] Key {

get { return key; }

set { key = value; }

}

/// <summary>

/// Password to be used for encrypting/decrypting files.

/// </summary>

/// <remarks>Set to null if no password is required.</remarks>

public string Password {

set {

if (string.IsNullOrEmpty(value)) {

key = null;

} else {

rawPassword_ = value;

key = PkzipClassic.GenerateKeys(ZipConstants.ConvertToArray(value));

}

}

}

/// <summary>

/// Get a value indicating wether encryption keys are currently available.

/// </summary>

bool HaveKeys {

get { return key != null; }

}

#endregion

#region Constructors

/// <summary>

/// Opens a Zip file with the given name for reading.

/// </summary>

/// <param name="name">The name of the file to open.</param>

/// <exception cref="ArgumentNullException">The argument supplied is null.</exception>

/// <exception cref="IOException">

/// An i/o error occurs

/// </exception>

/// <exception cref="ZipException">

/// The file doesn't contain a valid zip archive.

/// </exception>

public ZipFile(string name)

{

if (name == null) {

throw new ArgumentNullException(nameof(name));

}

name_ = name;

baseStream_ = File.Open(name, FileMode.Open, FileAccess.Read, FileShare.Read);

isStreamOwner = true;

try {

ReadEntries();

} catch {

DisposeInternal(true);

throw;

}

}

/// <summary>

/// Opens a Zip file reading the given <see cref="FileStream"/>.

/// </summary>

/// <param name="file">The <see cref="FileStream"/> to read archive data from.</param>

/// <exception cref="ArgumentNullException">The supplied argument is null.</exception>

/// <exception cref="IOException">

/// An i/o error occurs.

/// </exception>

/// <exception cref="ZipException">

/// The file doesn't contain a valid zip archive.

/// </exception>

public ZipFile(FileStream file)

{

if (file == null) {

throw new ArgumentNullException(nameof(file));

}

if (!file.CanSeek) {

throw new ArgumentException("Stream is not seekable", nameof(file));

}

baseStream_ = file;

name_ = file.Name;

isStreamOwner = true;

try {

ReadEntries();

} catch {

DisposeInternal(true);

throw;

}

}

/// <summary>

/// Opens a Zip file reading the given <see cref="Stream"/>.

/// </summary>

/// <param name="stream">The <see cref="Stream"/> to read archive data from.</param>

/// <exception cref="IOException">

/// An i/o error occurs

/// </exception>

/// <exception cref="ZipException">

/// The stream doesn't contain a valid zip archive.<br/>

/// </exception>

/// <exception cref="ArgumentException">

/// The <see cref="Stream">stream</see> doesnt support seeking.

/// </exception>

/// <exception cref="ArgumentNullException">

/// The <see cref="Stream">stream</see> argument is null.

/// </exception>

public ZipFile(Stream stream)

{

if (stream == null) {

throw new ArgumentNullException(nameof(stream));

}

if (!stream.CanSeek) {

throw new ArgumentException("Stream is not seekable", nameof(stream));

}

baseStream_ = stream;

isStreamOwner = true;

if (baseStream_.Length > 0) {

try {

ReadEntries();

} catch {

DisposeInternal(true);

throw;

}

} else {

entries_ = new ZipEntry[0];

isNewArchive_ = true;

}

}

/// <summary>

/// Initialises a default <see cref="ZipFile"/> instance with no entries and no file storage.

/// </summary>

internal ZipFile()

{

entries_ = new ZipEntry[0];

isNewArchive_ = true;

}

#endregion

#region Destructors and Closing

/// <summary>

/// Finalize this instance.

/// </summary>

~ZipFile()

{

Dispose(false);

}

/// <summary>

/// Closes the ZipFile. If the stream is <see cref="IsStreamOwner">owned</see> then this also closes the underlying input stream.

/// Once closed, no further instance methods should be called.

/// </summary>

/// <exception cref="System.IO.IOException">

/// An i/o error occurs.

/// </exception>

public void Close()

{

DisposeInternal(true);

GC.SuppressFinalize(this);

}

#endregion

#region Creators

/// <summary>

/// Create a new <see cref="ZipFile"/> whose data will be stored in a file.

/// </summary>

/// <param name="fileName">The name of the archive to create.</param>

/// <returns>Returns the newly created <see cref="ZipFile"/></returns>

/// <exception cref="ArgumentNullException"><paramref name="fileName"></paramref> is null</exception>

public static ZipFile Create(string fileName)

{

if (fileName == null) {

throw new ArgumentNullException(nameof(fileName));

}

FileStream fs = File.Create(fileName);

var result = new ZipFile();

result.name_ = fileName;

result.baseStream_ = fs;

result.isStreamOwner = true;

return result;

}

/// <summary>

/// Create a new <see cref="ZipFile"/> whose data will be stored on a stream.

/// </summary>

/// <param name="outStream">The stream providing data storage.</param>

/// <returns>Returns the newly created <see cref="ZipFile"/></returns>

/// <exception cref="ArgumentNullException"><paramref name="outStream"> is null</paramref></exception>

/// <exception cref="ArgumentException"><paramref name="outStream"> doesnt support writing.</paramref></exception>

public static ZipFile Create(Stream outStream)

{

if (outStream == null) {

throw new ArgumentNullException(nameof(outStream));

}

if (!outStream.CanWrite) {

throw new ArgumentException("Stream is not writeable", nameof(outStream));

}

if (!outStream.CanSeek) {

throw new ArgumentException("Stream is not seekable", nameof(outStream));

}

var result = new ZipFile();

result.baseStream_ = outStream;

return result;

}

#endregion

#region Properties

/// <summary>

/// Get/set a flag indicating if the underlying stream is owned by the ZipFile instance.

/// If the flag is true then the stream will be closed when <see cref="Close">Close</see> is called.

/// </summary>

/// <remarks>

/// The default value is true in all cases.

/// </remarks>

public bool IsStreamOwner {

get { return isStreamOwner; }

set { isStreamOwner = value; }

}

/// <summary>

/// Get a value indicating wether

/// this archive is embedded in another file or not.

/// </summary>

public bool IsEmbeddedArchive {

// Not strictly correct in all circumstances currently

get { return offsetOfFirstEntry > 0; }

}

/// <summary>

/// Get a value indicating that this archive is a new one.

/// </summary>

public bool IsNewArchive {

get { return isNewArchive_; }

}

/// <summary>

/// Gets the comment for the zip file.

/// </summary>

public string ZipFileComment {

get { return comment_; }

}

/// <summary>

/// Gets the name of this zip file.

/// </summary>

public string Name {

get { return name_; }

}

/// <summary>

/// Gets the number of entries in this zip file.

/// </summary>

/// <exception cref="InvalidOperationException">

/// The Zip file has been closed.

/// </exception>

[Obsolete("Use the Count property instead")]

public int Size {

get {

return entries_.Length;

}

}

/// <summary>

/// Get the number of entries contained in this <see cref="ZipFile"/>.

/// </summary>

public long Count {

get {

return entries_.Length;

}

}

/// <summary>

/// Indexer property for ZipEntries

/// </summary>

[System.Runtime.CompilerServices.IndexerNameAttribute("EntryByIndex")]

public ZipEntry this[int index] {

get {

return (ZipEntry)entries_[index].Clone();

}

}

#endregion

#region Input Handling

/// <summary>

/// Gets an enumerator for the Zip entries in this Zip file.

/// </summary>

/// <returns>Returns an <see cref="IEnumerator"/> for this archive.</returns>

/// <exception cref="ObjectDisposedException">

/// The Zip file has been closed.

/// </exception>

public IEnumerator GetEnumerator()

{

if (isDisposed_) {

throw new ObjectDisposedException("ZipFile");

}

return new ZipEntryEnumerator(entries_);

}

/// <summary>

/// Return the index of the entry with a matching name

/// </summary>

/// <param name="name">Entry name to find</param>

/// <param name="ignoreCase">If true the comparison is case insensitive</param>

/// <returns>The index position of the matching entry or -1 if not found</returns>

/// <exception cref="ObjectDisposedException">

/// The Zip file has been closed.

/// </exception>

public int FindEntry(string name, bool ignoreCase)

{

if (isDisposed_) {

throw new ObjectDisposedException("ZipFile");

}

// TODO: This will be slow as the next ice age for huge archives!

for (int i = 0; i < entries_.Length; i++) {

if (string.Compare(name, entries_[i].Name, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) == 0) {

return i;

}

}

return -1;

}

/// <summary>

/// Searches for a zip entry in this archive with the given name.

/// String comparisons are case insensitive

/// </summary>

/// <param name="name">

/// The name to find. May contain directory components separated by slashes ('/').

/// </param>

/// <returns>

/// A clone of the zip entry, or null if no entry with that name exists.

/// </returns>

/// <exception cref="ObjectDisposedException">

/// The Zip file has been closed.

/// </exception>

public ZipEntry GetEntry(string name)

{

if (isDisposed_) {

throw new ObjectDisposedException("ZipFile");

}

int index = FindEntry(name, true);

return (index >= 0) ? (ZipEntry)entries_[index].Clone() : null;

}

/// <summary>

/// Gets an input stream for reading the given zip entry data in an uncompressed form.

/// Normally the <see cref="ZipEntry"/> should be an entry returned by GetEntry().

/// </summary>

/// <param name="entry">The <see cref="ZipEntry"/> to obtain a data <see cref="Stream"/> for</param>

/// <returns>An input <see cref="Stream"/> containing data for this <see cref="ZipEntry"/></returns>

/// <exception cref="ObjectDisposedException">

/// The ZipFile has already been closed

/// </exception>

/// <exception cref="ICSharpCode.SharpZipLib.Zip.ZipException">

/// The compression method for the entry is unknown

/// </exception>

/// <exception cref="IndexOutOfRangeException">

/// The entry is not found in the ZipFile

/// </exception>

public Stream GetInputStream(ZipEntry entry)

{

if (entry == null) {

throw new ArgumentNullException(nameof(entry));

}

if (isDisposed_) {

throw new ObjectDisposedException("ZipFile");

}

long index = entry.ZipFileIndex;

if ((index < 0) || (index >= entries_.Length) || (entries_[index].Name != entry.Name)) {

index = FindEntry(entry.Name, true);

if (index < 0) {

throw new ZipException("Entry cannot be found");

}

}

return GetInputStream(index);

}

/// <summary>

/// Creates an input stream reading a zip entry

/// </summary>

/// <param name="entryIndex">The index of the entry to obtain an input stream for.</param>

/// <returns>

/// An input <see cref="Stream"/> containing data for this <paramref name="entryIndex"/>

/// </returns>

/// <exception cref="ObjectDisposedException">

/// The ZipFile has already been closed

/// </exception>

/// <exception cref="ICSharpCode.SharpZipLib.Zip.ZipException">

/// The compression method for the entry is unknown

/// </exception>

/// <exception cref="IndexOutOfRangeException">

/// The entry is not found in the ZipFile

/// </exception>

public Stream GetInputStream(long entryIndex)

{

if (isDisposed_) {

throw new ObjectDisposedException("ZipFile");

}

long start = LocateEntry(entries_[entryIndex]);

CompressionMethod method = entries_[entryIndex].CompressionMethod;

Stream result = new PartialInputStream(this, start, entries_[entryIndex].CompressedSize);

if (entries_[entryIndex].IsCrypted == true) {

result = CreateAndInitDecryptionStream(result, entries_[entryIndex]);

if (result == null) {

throw new ZipException("Unable to decrypt this entry");

}

}

switch (method) {

case CompressionMethod.Stored:

// read as is.

break;

case CompressionMethod.Deflated:

// No need to worry about ownership and closing as underlying stream close does nothing.

result = new InflaterInputStream(result, new Inflater(true));

break;

default:

throw new ZipException("Unsupported compression method " + method);

}

return result;

}

#endregion

#region Archive Testing

/// <summary>

/// Test an archive for integrity/validity

/// </summary>

/// <param name="testData">Perform low level data Crc check</param>

/// <returns>true if all tests pass, false otherwise</returns>

/// <remarks>Testing will terminate on the first error found.</remarks>

public bool TestArchive(bool testData)

{

return TestArchive(testData, TestStrategy.FindFirstError, null);

}

/// <summary>

/// Test an archive for integrity/validity

/// </summary>

/// <param name="testData">Perform low level data Crc check</param>

/// <param name="strategy">The <see cref="TestStrategy"></see> to apply.</param>

/// <param name="resultHandler">The <see cref="ZipTestResultHandler"></see> handler to call during testing.</param>

/// <returns>true if all tests pass, false otherwise</returns>

/// <exception cref="ObjectDisposedException">The object has already been closed.</exception>

public bool TestArchive(bool testData, TestStrategy strategy, ZipTestResultHandler resultHandler)

{

if (isDisposed_) {

throw new ObjectDisposedException("ZipFile");

}

var status = new TestStatus(this);

if (resultHandler != null) {

resultHandler(status, null);

}

HeaderTest test = testData ? (HeaderTest.Header | HeaderTest.Extract) : HeaderTest.Header;

bool testing = true;

try {

int entryIndex = 0;

while (testing && (entryIndex < Count)) {

if (resultHandler != null) {

status.SetEntry(this[entryIndex]);

status.SetOperation(TestOperation.EntryHeader);

resultHandler(status, null);

}

try {

TestLocalHeader(this[entryIndex], test);

} catch (ZipException ex) {

status.AddError();

if (resultHandler != null) {

resultHandler(status,

string.Format("Exception during test - '{0}'", ex.Message));

}

testing &= strategy != TestStrategy.FindFirstError;

}

if (testing && testData && this[entryIndex].IsFile) {

if (resultHandler != null) {

status.SetOperation(TestOperation.EntryData);

resultHandler(status, null);

}

var crc = new Crc32();

using (Stream entryStream = this.GetInputStream(this[entryIndex])) {

byte[] buffer = new byte[4096];

long totalBytes = 0;

int bytesRead;

while ((bytesRead = entryStream.Read(buffer, 0, buffer.Length)) > 0) {

crc.Update(buffer, 0, bytesRead);

if (resultHandler != null) {

totalBytes += bytesRead;

status.SetBytesTested(totalBytes);

resultHandler(status, null);

}

}

}

if (this[entryIndex].Crc != crc.Value) {

status.AddError();

if (resultHandler != null) {

resultHandler(status, "CRC mismatch");

}

testing &= strategy != TestStrategy.FindFirstError;

}

if ((this[entryIndex].Flags & (int)GeneralBitFlags.Descriptor) != 0) {

var helper = new ZipHelperStream(baseStream_);

var data = new DescriptorData();

helper.ReadDataDescriptor(this[entryIndex].LocalHeaderRequiresZip64, data);

if (this[entryIndex].Crc != data.Crc) {

status.AddError();

}

if (this[entryIndex].CompressedSize != data.CompressedSize) {

status.AddError();

}

if (this[entryIndex].Size != data.Size) {

status.AddError();

}

}

}

if (resultHandler != null) {

status.SetOperation(TestOperation.EntryComplete);

resultHandler(status, null);

}

entryIndex += 1;

}

if (resultHandler != null) {

status.SetOperation(TestOperation.MiscellaneousTests);

resultHandler(status, null);

}

// TODO: the 'Corrina Johns' test where local headers are missing from

// the central directory. They are therefore invisible to many archivers.

} catch (Exception ex) {

status.AddError();

if (resultHandler != null) {

resultHandler(status, string.Format("Exception during test - '{0}'", ex.Message));

}

}

if (resultHandler != null) {

status.SetOperation(TestOperation.Complete);

status.SetEntry(null);

resultHandler(status, null);

}

return (status.ErrorCount == 0);

}

[Flags]

enum HeaderTest

{

Extract = 0x01, // Check that this header represents an entry whose data can be extracted

Header = 0x02, // Check that this header contents are valid

}

/// <summary>

/// Test a local header against that provided from the central directory

/// </summary>

/// <param name="entry">

/// The entry to test against

/// </param>

/// <param name="tests">The type of <see cref="HeaderTest">tests</see> to carry out.</param>

/// <returns>The offset of the entries data in the file</returns>

long TestLocalHeader(ZipEntry entry, HeaderTest tests)

{

lock (baseStream_) {

bool testHeader = (tests & HeaderTest.Header) != 0;

bool testData = (tests & HeaderTest.Extract) != 0;

baseStream_.Seek(offsetOfFirstEntry + entry.Offset, SeekOrigin.Begin);

if ((int)ReadLEUint() != ZipConstants.LocalHeaderSignature) {

throw new ZipException(string.Format("Wrong local header signature @{0:X}", offsetOfFirstEntry + entry.Offset));

}

var extractVersion = (short)(ReadLEUshort() & 0x00ff);

var localFlags = (short)ReadLEUshort();

var compressionMethod = (short)ReadLEUshort();

var fileTime = (short)ReadLEUshort();

var fileDate = (short)ReadLEUshort();

uint crcValue = ReadLEUint();

long compressedSize = ReadLEUint();

long size = ReadLEUint();

int storedNameLength = ReadLEUshort();

int extraDataLength = ReadLEUshort();

byte[] nameData = new byte[storedNameLength];

StreamUtils.ReadFully(baseStream_, nameData);

byte[] extraData = new byte[extraDataLength];

StreamUtils.ReadFully(baseStream_, extraData);

var localExtraData = new ZipExtraData(extraData);

// Extra data / zip64 checks

if (localExtraData.Find(1)) {

// 2010-03-04 Forum 10512: removed checks for version >= ZipConstants.VersionZip64

// and size or compressedSize = MaxValue, due to rogue creators.

size = localExtraData.ReadLong();

compressedSize = localExtraData.ReadLong();

if ((localFlags & (int)GeneralBitFlags.Descriptor) != 0) {

// These may be valid if patched later

if ((size != -1) && (size != entry.Size)) {

throw new ZipException("Size invalid for descriptor");

}

if ((compressedSize != -1) && (compressedSize != entry.CompressedSize)) {

throw new ZipException("Compressed size invalid for descriptor");

}

}

} else {

// No zip64 extra data but entry requires it.

if ((extractVersion >= ZipConstants.VersionZip64) &&

(((uint)size == uint.MaxValue) || ((uint)compressedSize == uint.MaxValue))) {

throw new ZipException("Required Zip64 extended information missing");

}

}

if (testData) {

if (entry.IsFile) {

if (!entry.IsCompressionMethodSupported()) {

throw new ZipException("Compression method not supported");

}

if ((extractVersion > ZipConstants.VersionMadeBy)

|| ((extractVersion > 20) && (extractVersion < ZipConstants.VersionZip64))) {

throw new ZipException(string.Format("Version required to extract this entry not supported ({0})", extractVersion));

}

if ((localFlags & (int)(GeneralBitFlags.Patched | GeneralBitFlags.StrongEncryption | GeneralBitFlags.EnhancedCompress | GeneralBitFlags.HeaderMasked)) != 0) {

throw new ZipException("The library does not support the zip version required to extract this entry");

}

}

}

if (testHeader) {

if ((extractVersion <= 63) && // Ignore later versions as we dont know about them..

(extractVersion != 10) &&

(extractVersion != 11) &&