Synnefo » Pithos MS Client

// ZipFile.cs

//

// Copyright (C) 2001 Mike Krueger

// Copyright (C) 2004 John Reilly

//

// This file was translated from java, it was part of the GNU Classpath

// Copyright (C) 2001 Free Software Foundation, Inc.

//

// This program is free software; you can redistribute it and/or

// modify it under the terms of the GNU General Public License

// as published by the Free Software Foundation; either version 2

// of the License, or (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

//

// Linking this library statically or dynamically with other modules is

// making a combined work based on this library.  Thus, the terms and

// conditions of the GNU General Public License cover the whole

// combination.

// 

// As a special exception, the copyright holders of this library give you

// permission to link this library with independent modules to produce an

// executable, regardless of the license terms of these independent

// modules, and to copy and distribute the resulting executable under

// terms of your choice, provided that you also meet, for each linked

// independent module, the terms and conditions of the license of that

// module.  An independent module is a module which is not derived from

// or based on this library.  If you modify this library, you may extend

// this exception to your version of the library, but you are not

// obligated to do so.  If you do not wish to do so, delete this

// exception statement from your version.

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Text;

using System.Globalization;

using System.Security.Cryptography;

using ICSharpCode.SharpZipLib.Silverlight.Checksums;

using ICSharpCode.SharpZipLib.Silverlight.Core;

using ICSharpCode.SharpZipLib.Silverlight.Compat;

using ICSharpCode.SharpZipLib.Silverlight.Encryption;

using ICSharpCode.SharpZipLib.Silverlight.Zip;

using ICSharpCode.SharpZipLib.Silverlight.Zip.Compression;

using ICSharpCode.SharpZipLib.Silverlight.Zip.Compression.Streams;

using ICSharpCode.SharpZipLib.Zip;

namespace ICSharpCode.SharpZipLib.Silverlight.Zip

{

    /// <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>

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

        /// </summary>

        public string FileName

        {

            get { return fileName; }

        }

        /// <summary>

        /// Get/set the key value

        /// </summary>

        public byte[] Key

        {

            get { return key; }

            set { key = value; }

        }

        #endregion

        #region Instance Fields

        string fileName;

        byte[] key;

        #endregion

    }

    /// <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);

    /// <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,

    }

    /// <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) {

                KeysRequiredEventArgs 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 ( (value == null) || (value.Length == 0) ) {

                    key = null;

                }

                else {

                    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="IOException">

        /// An i/o error occurs

        /// </exception>

        /// <exception cref="ZipException">

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

        /// </exception>

        public ZipFile(string name)

        {

            name_ = name;

            baseStream_ = File.OpenRead(name);

            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="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("file");

            }

            if ( !file.CanSeek ) {

                throw new ArgumentException("Stream is not seekable", "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 file doesn't contain a valid zip archive.<br/>

        /// The stream provided cannot seek

        /// </exception>

        public ZipFile(Stream stream)

        {

            if ( stream == null ) {

                throw new ArgumentNullException("stream");

            }

            if ( !stream.CanSeek ) {

                throw new ArgumentException("Stream is not seekable", "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>

        public static ZipFile Create(string fileName)

        {

            if ( fileName == null ) {

                throw new ArgumentNullException("fileName");

            }

            FileStream fs = File.Create(fileName);

            ZipFile 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>

        public static ZipFile Create(Stream outStream)

        {

            if ( outStream == null ) {

                throw new ArgumentNullException("outStream");

            }

            if ( !outStream.CanWrite ) {

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

            }

            if ( !outStream.CanSeek ) {

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

            }

            ZipFile 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 

            {

                if (entries_ != null) {

                    return entries_.Length;

                } else {

                    throw new InvalidOperationException("ZipFile is closed");

                }

            }

        }

        /// <summary>

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

        /// </summary>

        public long Count 

        {

            get 

            {

                if (entries_ != null) {

                    return entries_.Length;

                } else {

                    throw new InvalidOperationException("ZipFile is closed");

                }

            }

        }

        /// <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="InvalidOperationException">

        /// The Zip file has been closed.

        /// </exception>

        public IEnumerator GetEnumerator()

        {

            if (entries_ == null) {

                throw new InvalidOperationException("ZipFile has closed");

            }

            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="InvalidOperationException">

        /// The Zip file has been closed.

        /// </exception>

        public int FindEntry(string name, bool ignoreCase)

        {

            if (entries_ == null) {

                throw new InvalidOperationException("ZipFile has been closed");

            }

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

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

                // BUG: Throws MissingMethodException!

                // CompareOptions options = (ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);

                // int comparison = string.Compare(name, entries_[i].Name, CultureInfo.InvariantCulture, options);

                if (name.Compare(entries_[i].Name, ignoreCase, CultureInfo.InvariantCulture) == 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="InvalidOperationException">

        /// The Zip file has been closed.

        /// </exception>

        public ZipEntry GetEntry(string name)

        {

            if (entries_ == null) {

                throw new InvalidOperationException("ZipFile has been closed");

            }

            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="InvalidOperationException">

        /// The ZipFile has already been closed

        /// </exception>

        /// <exception cref="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("entry");

            }

            if ( entries_ == null ) {

                throw new InvalidOperationException("ZipFile has closed");

            }

            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="InvalidOperationException">

        /// The ZipFile has already been closed

        /// </exception>

        /// <exception cref="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 ( entries_ == null ) {

                throw new InvalidOperationException("ZipFile is not open");

            }

            long start = LocateEntry(entries_[entryIndex]);

            CompressionMethod method = entries_[entryIndex].CompressionMethod;

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

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

#if NETCF_1_0

				throw new ZipException("decryption not supported for Compact Framework 1.0");

#else

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

                if (result == null) {

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

                }

#endif				

            }

            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>

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

        {

            TestStatus 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));

                        }

                        if ( strategy == TestStrategy.FindFirstError ) {

                            testing = false; 

                        }

                    }

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

                        if ( resultHandler != null ) {

                            status.SetOperation(TestOperation.EntryData);

                            resultHandler(status, null);

                        }

                        Stream entryStream = this.GetInputStream(this[entryIndex]);

                        Crc32 crc = new Crc32();

                        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");

                            }

                            if ( strategy == TestStrategy.FindFirstError ) {

                                testing = false;

                            }

                        }

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

                            ZipHelperStream helper = new ZipHelperStream(baseStream_);

                            DescriptorData 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));

                }

                short extractVersion = ( short )ReadLEUshort();

                short localFlags = ( short )ReadLEUshort();

                short compressionMethod = ( short )ReadLEUshort();

                short fileTime = ( short )ReadLEUshort();

                short 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);

                ZipExtraData ed = new ZipExtraData(extraData);

                // Extra data / zip64 checks

                if (ed.Find(1))

                {

                    // TODO Check for tag values being distinct..  Multiple zip64 tags means what?

                    // Zip64 extra data but 'extract version' is too low

                    if (extractVersion < ZipConstants.VersionZip64)

                    {

                        throw new ZipException(

                            string.Format("Extra data contains Zip64 information but version {0}.{1} is not high enough",

                                          extractVersion / 10, extractVersion % 10));

                    }

                    // Zip64 extra data but size fields dont indicate its required.

                    if (((uint)size != uint.MaxValue) && ((uint)compressedSize != uint.MaxValue))

                    {

                        throw new ZipException("Entry sizes not correct for Zip64");

                    }

                    size = ed.ReadLong();

                    compressedSize = ed.ReadLong();

                }

                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) &&

                        (extractVersion != 20) &&

                        (extractVersion != 21) &&

                        (extractVersion != 25) &&

                        (extractVersion != 27) &&

                        (extractVersion != 45) &&

                        (extractVersion != 46) &&

                        (extractVersion != 50) &&

                        (extractVersion != 51) &&

                        (extractVersion != 52) &&

                        (extractVersion != 61) &&

                        (extractVersion != 62) &&

                        (extractVersion != 63)

                        ) {

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

                        }

                    // Local entry flags dont have reserved bit set on.

                    if ( (localFlags & ( int )(GeneralBitFlags.ReservedPKware4 | GeneralBitFlags.ReservedPkware14 | GeneralBitFlags.ReservedPkware15)) != 0 ) {

                        throw new ZipException("Reserved bit flags cannot be set.");

                    }

                    // Encryption requires extract version >= 20

                    if ( ((localFlags & ( int )GeneralBitFlags.Encrypted) != 0) && (extractVersion < 20) ) {

                        throw new ZipException(string.Format("Version required to extract this entry is too low for encryption ({0})", extractVersion));

                    }

                    // Strong encryption requires encryption flag to be set and extract version >= 50.

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

                        if ( (localFlags & (int)GeneralBitFlags.Encrypted) == 0 ) {

                            throw new ZipException("Strong encryption flag set but encryption flag is not set");

                        }

                        if ( extractVersion < 50 ) {

                            throw new ZipException(string.Format("Version required to extract this entry is too low for encryption ({0})", extractVersion));

                        }

                    }

                    // Patched entries require extract version >= 27

                    if ( ((localFlags & ( int )GeneralBitFlags.Patched) != 0) && (extractVersion < 27) ) {

                        throw new ZipException(string.Format("Patched data requires higher version than ({0})", extractVersion));

                    }

                    // Central header flags match local entry flags.

                    if ( localFlags != entry.Flags ) {

                        throw new ZipException("Central header/local header flags mismatch");

                    }

                    // Central header compression method matches local entry

                    if ( entry.CompressionMethod != ( CompressionMethod )compressionMethod ) {

                        throw new ZipException("Central header/local header compression method mismatch");

                    }

                    // Strong encryption and extract version match

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

                        if ( extractVersion < 62 ) {

                            throw new ZipException("Strong encryption flag set but version not high enough");

                        }

                    }

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

                        if ( (fileTime != 0) || (fileDate != 0) ) {

                            throw new ZipException("Header masked set but date/time values non-zero");

                        }

                    }

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

                        if ( crcValue != (uint)entry.Crc ) {

                            throw new ZipException("Central header/local header crc mismatch");

                        }

                    }

                    // Crc valid for empty entry.

                    // This will also apply to streamed entries where size isnt known and the header cant be patched

                    if ( (size == 0) && (compressedSize == 0) ) {

                        if ( crcValue != 0 ) {

                            throw new ZipException("Invalid CRC for empty entry");

                        }

                    }

                    // TODO: make test more correct...  can't compare lengths as was done originally as this can fail for MBCS strings

                    // Assuming a code page at this point is not valid?  Best is to store the name length in the ZipEntry probably

                    if ( entry.Name.Length > storedNameLength ) {

                        throw new ZipException("File name length mismatch");

                    }

                    // Name data has already been read convert it and compare.

                    string localName = ZipConstants.ConvertToStringExt(localFlags, nameData);

                    // Central directory and local entry name match

                    if ( localName != entry.Name ) {

                        throw new ZipException("Central header and local header file name mismatch");

                    }

                    // Directories have zero size.

                    if ( entry.IsDirectory ) {

                        if ( (compressedSize != 0) || (size != 0) ) {

                            throw new ZipException("Directory cannot have size");

                        }

                    }

                    if ( !ZipNameTransform.IsValidName(localName, true) ) {

                        throw new ZipException("Name is invalid");

                    }

                }

                // Tests that apply to both data and header.

                // Size can be verified only if it is known in the local header.

                // it will always be known in the central header.

                if ((localFlags & (int)GeneralBitFlags.Descriptor) == 0 ||

                    (size != 0 || compressedSize != 0)) {

                        if (size != entry.Size) {

                            throw new ZipException(

                                string.Format("Size mismatch between central header({0}) and local header({1})",

                                              entry.Size, size));

                        }

                        if (compressedSize != entry.CompressedSize) {

                            throw new ZipException(

                                string.Format("Compressed size mismatch between central header({0}) and local header({1})",

                                              entry.CompressedSize, compressedSize));

                        }

                    }

                int extraLength = storedNameLength + extraDataLength;

                return offsetOfFirstEntry + entry.Offset + ZipConstants.LocalHeaderBaseSize + extraLength;

            }

        }

        #endregion

        #region Updating

        const int DefaultBufferSize = 4096;

        /// <summary>

        /// The kind of update to apply.

        /// </summary>

        enum UpdateCommand

        {

            Copy,       // Copy original file contents.

            Modify,     // Change encryption, compression, attributes, name, time etc, of an existing file.

            Add,        // Add a new file to the archive.

        }

        #region Properties

        /// <summary>

        /// Get / set the <see cref="INameTransform"/> to apply to names when updating.

        /// </summary>

        public INameTransform NameTransform

        {

            get {

                return updateEntryFactory_.NameTransform;

            }

            set {

                updateEntryFactory_.NameTransform = value;

            }

        }

        /// <summary>

        /// Get/set the <see cref="IEntryFactory"/> used to generate <see cref="ZipEntry"/> values

        /// during updates.

        /// </summary>

        public IEntryFactory EntryFactory

        {

            get {

                return updateEntryFactory_;

            }

            set {

                if (value == null) {

                    updateEntryFactory_ = new ZipEntryFactory();

                }

                else {

                    updateEntryFactory_ = value;

                }

            }

        }

        /// <summary>

        /// Get /set the buffer size to be used when updating this zip file.

        /// </summary>

        public int BufferSize

        {

            get { return bufferSize_; }

            set {

                if ( value < 1024 ) {

#if NETCF_1_0					

					throw new ArgumentOutOfRangeException("value");

#else

                    throw new ArgumentOutOfRangeException("value", "cannot be below 1024");

#endif					

                }

                if ( bufferSize_ != value ) {

                    bufferSize_ = value;

                    copyBuffer_ = null;

                }

            }

        }

        /// <summary>

        /// Get a value indicating an update has <see cref="BeginUpdate()">been started</see>.

        /// </summary>

        public bool IsUpdating

        {

            get { return updates_ != null; }

        }

        /// <summary>

        /// Get / set a value indicating how Zip64 Extension usage is determined when adding entries.

        /// </summary>

        public UseZip64 UseZip64

        {

            get { return useZip64_; }

            set { useZip64_ = value; }

        }

        #endregion

        #region Immediate updating

//		TBD: Direct form of updating

// 

//		public void Update(IEntryMatcher deleteMatcher)

//		{

//		}

//

//		public void Update(IScanner addScanner)

//		{

//		}

        #endregion

        #region Deferred Updating

        /// <summary>

        /// Begin updating this <see cref="ZipFile"/> archive.

        /// </summary>

        /// <param name="archiveStorage">The <see cref="IArchiveStorage">archive storage</see> for use during the update.</param>

        /// <param name="dataSource">The <see cref="IDynamicDataSource">data source</see> to utilise during updating.</param>

        public void BeginUpdate(IArchiveStorage archiveStorage, IDynamicDataSource dataSource)

        {

            if ( IsEmbeddedArchive ) {

                throw new ZipException ("Cannot update embedded/SFX archives");

            }

            if ( archiveStorage == null ) {

                throw new ArgumentNullException("archiveStorage");

            }

            if ( dataSource == null ) {

                throw new ArgumentNullException("dataSource");

            }

            archiveStorage_ = archiveStorage;

            updateDataSource_ = dataSource;

            // NOTE: the baseStream_ may not currently support writing or seeking.

            updateIndex_ = new Dictionary<string, int>();

            if ( entries_ != null ) {

                updates_ = new List<ZipUpdate>(entries_.Length);

                foreach(ZipEntry entry in entries_) {

                    ZipUpdate update = new ZipUpdate(entry);

                    updates_.Add(update);

                    int index = updates_.IndexOf(update);

                    updateIndex_.Add(entry.Name, index);

                }

            }

            else {

                updates_ = new List<ZipUpdate>();

            }

            updateCount_ = updates_.Count;

            contentsEdited_ = false;

            commentEdited_ = false;

            newComment_ = null;

        }

        /// <summary>

        /// Begin updating to this <see cref="ZipFile"/> archive.

        /// </summary>

        /// <param name="archiveStorage">The storage to use during the update.</param>

        public void BeginUpdate(IArchiveStorage archiveStorage)

        {

            BeginUpdate(archiveStorage, new DynamicDiskDataSource());

        }

        /// <summary>

        /// Begin updating this <see cref="ZipFile"/> archive.

        /// </summary>

        /// <seealso cref="BeginUpdate(IArchiveStorage)"/>

        /// <seealso cref="CommitUpdate"></seealso>

        /// <seealso cref="AbortUpdate"></seealso>

        public void BeginUpdate()

        {

            if ( Name == null ) {

                BeginUpdate(new MemoryArchiveStorage(), new DynamicDiskDataSource());

            }

            else {

                BeginUpdate(new DiskArchiveStorage(this), new DynamicDiskDataSource());

            }

        }

        /// <summary>

        /// Commit current updates, updating this archive.

        /// </summary>

        /// <seealso cref="BeginUpdate()"></seealso>

        /// <seealso cref="AbortUpdate"></seealso>

        public void CommitUpdate()

        {

            CheckUpdating();

            try

            {

                updateIndex_.Clear();

                updateIndex_=null;

                if( contentsEdited_ ) {

                    RunUpdates();

                }

                else if( commentEdited_ ) {

                    UpdateCommentOnly();

                }

                else {

                    // Create an empty archive if none existed originally.

                    if( (entries_!=null)&&(entries_.Length==0) ) {

                        byte[] theComment=(newComment_!=null)?newComment_.RawComment:ZipConstants.ConvertToArray(comment_);

                        using( ZipHelperStream zhs=new ZipHelperStream(baseStream_) ) {

                            zhs.WriteEndOfCentralDirectory(0, 0, 0, theComment);

                        }

                    }

                }

            }

            finally {

                PostUpdateCleanup();

            }

        }

        /// <summary>

        /// Abort updating leaving the archive unchanged.

        /// </summary>

        /// <seealso cref="BeginUpdate()"></seealso>

        /// <seealso cref="CommitUpdate"></seealso>

        public void AbortUpdate()

        {

            PostUpdateCleanup();

        }

        /// <summary>

        /// Set the file comment to be recorded when the current update is <see cref="CommitUpdate">commited</see>.

        /// </summary>

        /// <param name="comment">The comment to record.</param>

        public void SetComment(string comment)

        {

            CheckUpdating();

            newComment_ = new ZipString(comment);

            if ( newComment_.RawLength  > 0xffff ) {

                newComment_ = null;

                throw new ZipException("Comment length exceeds maximum - 65535");

            }

            // We dont take account of the original and current comment appearing to be the same

            // as encoding may be different.

            commentEdited_ = true;

        }

        #endregion

        #region Adding Entries

        void AddUpdate(ZipUpdate update)

        {

            contentsEdited_ = true;

            int index = FindExistingUpdate(update.Entry.Name);

            if (index >= 0) {

                if ( updates_[index] == null ) {

                    updateCount_ += 1;

                }

                // Direct replacement is faster than delete and add.

                updates_[index] = update;

            }

            else {

                updates_.Add(update);

                index = updates_.IndexOf(update);

                updateCount_ += 1;

                updateIndex_.Add(update.Entry.Name, index);

            }

        }

        /// <summary>

        /// Add a new entry to the archive.

        /// </summary>

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

        /// <param name="compressionMethod">The compression method to use.</param>

        /// <param name="useUnicodeText">Ensure Unicode text is used for name and comment for this entry.</param>

        public void Add(string fileName, CompressionMethod compressionMethod, bool useUnicodeText )

        {

            if (fileName == null) {

                throw new ArgumentNullException("fileName");

            }

            if (!ZipEntry.IsCompressionMethodSupported(compressionMethod)) {

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

            }

            CheckUpdating();

            contentsEdited_ = true;

            ZipEntry entry = EntryFactory.MakeFileEntry(fileName);

            entry.IsUnicodeText = useUnicodeText;

            entry.CompressionMethod = compressionMethod;

            AddUpdate(new ZipUpdate(fileName, entry));

        }

        /// <summary>

        /// Add a new entry to the archive.

        /// </summary>

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

        /// <param name="compressionMethod">The compression method to use.</param>

        public void Add(string fileName, CompressionMethod compressionMethod)

        {

            if ( fileName == null ) {

                throw new ArgumentNullException("fileName");

            }

            if ( !ZipEntry.IsCompressionMethodSupported(compressionMethod) ) {

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

            }

            CheckUpdating();

            contentsEdited_ = true;

            ZipEntry entry = EntryFactory.MakeFileEntry(fileName);

            entry.CompressionMethod = compressionMethod;

            AddUpdate(new ZipUpdate(fileName, entry));

        }

        /// <summary>

        /// Add a file to the archive.

        /// </summary>

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

        public void Add(string fileName)

        {

            if ( fileName == null ) {

                throw new ArgumentNullException("fileName");

            }

            CheckUpdating();

            AddUpdate(new ZipUpdate(fileName, EntryFactory.MakeFileEntry(fileName)));

        }

        /// <summary>

        /// Add a file entry with data.

        /// </summary>

        /// <param name="dataSource">The source of the data for this entry.</param>

        /// <param name="entryName">The name to give to the entry.</param>

        public void Add(IStaticDataSource dataSource, string entryName)

        {

            if ( dataSource == null ) {

                throw new ArgumentNullException("dataSource");

            }

            CheckUpdating();

            AddUpdate(new ZipUpdate(dataSource, EntryFactory.MakeFileEntry(entryName)));

        }

        /// <summary>

        /// Add a file entry with data.

        /// </summary>

        /// <param name="dataSource">The source of the data for this entry.</param>

        /// <param name="entryName">The name to give to the entry.</param>

        /// <param name="compressionMethod">The compression method to use.</param>

        public void Add(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod)

        {

            if ( dataSource == null ) {

                throw new ArgumentNullException("dataSource");

            }

            CheckUpdating();

            ZipEntry entry = EntryFactory.MakeFileEntry(entryName, false);

            entry.CompressionMethod = compressionMethod;

            AddUpdate(new ZipUpdate(dataSource, entry));

        }

        /// <summary>

        /// Add a file entry with data.

        /// </summary>

        /// <param name="dataSource">The source of the data for this entry.</param>

        /// <param name="entryName">The name to give to the entry.</param>

        /// <param name="compressionMethod">The compression method to use.</param>

        /// <param name="useUnicodeText">Ensure Unicode text is used for name and comments for this entry.</param>

        public void Add(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod, bool useUnicodeText)

        {

            if (dataSource == null) {

                throw new ArgumentNullException("dataSource");

            }

            CheckUpdating();

            ZipEntry entry = EntryFactory.MakeFileEntry(entryName, false);

            entry.IsUnicodeText = useUnicodeText;