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

// HISTORY

// 2009-12-22 Z-1649 Added AES support

// 2010-03-02 Z-1650 Fixed updating ODT archives in memory. Exposed exceptions in updating.

// 2010-05-25 Z-1663 Fixed exception when testing local header compressed size of -1

using System;

using System.Collections;

using System.IO;

using System.Text;

using System.Globalization;

#if !NETCF_1_0

using System.Security.Cryptography;

using ICSharpCode.SharpZipLib.Encryption;

#endif

using ICSharpCode.SharpZipLib.Core;

using ICSharpCode.SharpZipLib.Checksums;

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

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; }

}

#if !NETCF_1_0

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

rawPassword_ = value;

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

}

}

}

#endif

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

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

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>

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

{

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, 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="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("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) {

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

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

}

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

}

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

}

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

{