/Utilities/Compression/Streams/ZipInputStream.cs

// Based on Mike Krueger's SharpZipLib, Copyright (C) 2001 (GNU license).

// Authors of the original java version: Jochen Hoenicke, John Leuner

// See http://www.ISeeSharpCode.com for more information.



using System;

using System.IO;

using System.Text;

using Delta.Utilities.Compression.Checksums;

using Delta.Utilities.Compression.Inflaters;

using Delta.Utilities.Helpers;



namespace Delta.Utilities.Compression.Streams

{



	#region Summary

	/// <summary>

	/// This is an InflaterInputStream that reads the files baseInputStream an

	/// zip archive one after another. It has a special method to get the zip

	/// entry of the next file. The zip entry contains information about the

	/// file name size, compressed size, Crc, etc.

	/// It includes support for Stored and Deflated entries.

	/// </summary>

	/// <example>This sample shows how to read a zip file

	/// <code lang="C#">

	/// using System;

	/// using System.Text;

	/// using System.IO;

	/// using Delta.Utilities.Compression;

	/// 

	/// class MainClass

	/// {

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

	/// 	{

	/// 		ZipInputStream s = new ZipInputStream(File.OpenRead(args[0]));

	/// 		

	/// 		ZipEntry theEntry;

	/// 		while ((theEntry = s.GetNextEntry()) != null)

	///     {

	/// 			int size = 2048;

	/// 			byte[] data = new byte[2048];

	/// 			

	/// 			Console.Write("Show contents (y/n) ?");

	/// 			if (Console.ReadLine() == "y")

	///       {

	/// 				while (true)

	///         {

	/// 					size = s.Read(data, 0, data.Length);

	/// 					if (size > 0)

	///           {

	/// 						Console.Write(new ASCIIEncoding().GetString(data, 0, size));

	/// 					} // if

	///           else

	///           {

	/// 						break;

	/// 					} // else

	/// 				} // while

	/// 			} // if

	/// 		} // while

	/// 		s.Close();

	/// 	} // Main(args)

	/// }	// class MainClass

	/// </code>

	/// </example>

	#endregion



	public class ZipInputStream : InflaterInputStream

	{

		#region Delegates

		/// <summary>

		/// Delegate for reading bytes from a stream.

		/// </summary>

		/// <param name="buffer">Buffer</param>

		/// <param name="offset">Offset</param>

		/// <param name="length">Length</param>

		/// <returns>Number of bytes read</returns>

		private delegate int ReaderDelegate(byte[] buffer, int offset, int length);

		#endregion



		#region Password (Public)

		/// <summary>

		/// Optional password used for encryption when non-null

		/// </summary>

		public string Password

		{

			get

			{

				return password;

			} // get

			set

			{

				password = value;

			} // set

		}

		#endregion



		#region CanDecompressEntry (Public)

		/// <summary>

		/// Gets a value indicating if the entry can be decompressed

		/// </summary>

		/// <remarks>

		/// The entry can only be decompressed if the library supports the zip

		/// features required to extract it. See the

		/// <see cref="ZipEntry.Version">ZipEntry Version</see> property for more

		/// details.

		/// </remarks>

		public bool CanDecompressEntry

		{

			get

			{

				return entry != null && entry.Version <= ZipConstants.VersionMadeBy;

			} // get

		}

		#endregion



		#region IsEntryAvailable (Public)

		/// <summary>

		/// Returns 1 if there is an entry available

		/// Otherwise returns 0.

		/// </summary>

		public override int IsEntryAvailable

		{

			get

			{

				return entry != null

				       	? 1

				       	: 0;

			} // get

		}

		#endregion



		#region Private



		#region internalReader (Private)

		/// <summary>

		/// The current reader this instance.

		/// </summary>

		private ReaderDelegate internalReader;

		#endregion



		#region crc (Private)

		/// <summary>

		/// Crc32 checksum

		/// </summary>

		private Crc32 crc = new Crc32();

		#endregion



		#region entry (Private)

		/// <summary>

		/// Entry

		/// </summary>

		private ZipEntry entry;

		#endregion



		#region size (Private)

		/// <summary>

		/// Size

		/// </summary>

		private long size;

		#endregion



		#region method (Private)

		/// <summary>

		/// Method

		/// </summary>

		private int method;

		#endregion



		#region flags (Private)

		/// <summary>

		/// Flags

		/// </summary>

		private int flags;

		#endregion



		#region password (Private)

		/// <summary>

		/// Password

		/// </summary>

		private string password;

		#endregion



		#endregion



		#region Constructors

		/// <summary>

		/// Creates a new Zip input stream, for reading a zip archive.

		/// </summary>

		public ZipInputStream(Stream baseInputStream)

			: base(baseInputStream, new Inflater(true))

		{

			internalReader = InitialRead;

		}

		#endregion



		#region GetNextEntry (Public)

		/// <summary>

		/// Advances to the next entry in the archive

		/// </summary>

		/// <returns>

		/// The next <see cref="ZipEntry">entry</see> in the archive or null if

		/// there are no more entries.

		/// </returns>

		/// <remarks>

		/// If the previous entry is still open

		/// <see cref="CloseEntry">CloseEntry</see> is called.

		/// </remarks>

		/// <exception cref="InvalidOperationException">

		/// Input stream is closed

		/// </exception>

		/// <exception cref="ZipException">

		/// Password is not set, password is invalid, compression method is

		/// invalid, version required to extract is not supported.

		/// </exception>

		public ZipEntry GetNextEntry()

		{

			if (crc == null)

			{

				throw new InvalidOperationException("Closed.");

			}



			if (entry != null)

			{

				CloseEntry();

			}



			int header = inputBuffer.ReadLeInt();



			if (header == ZipConstants.CentralDirectorySig ||

			    header == ZipConstants.EndSig ||

			    header == ZipConstants.CentralDigitalSig ||

			    header == ZipConstants.CentralDirectorySig64)

			{

				// No more individual entries exist

				Close();

				return null;

			}



			// -jr- 07-Dec-2003 Ignore spanning temporary signatures if found

			// SpanningSig is same as descriptor signature and is untested as yet.

			if (header == ZipConstants.SpanningTempSig ||

			    header == ZipConstants.SpanningSig)

			{

				header = inputBuffer.ReadLeInt();

			}



			if (header != ZipConstants.LocalSignature)

			{

				throw new ZipException(

					"Wrong Local header signature: 0x" + String.Format("{0:X}", header));

			}



			short versionRequiredToExtract = (short)inputBuffer.ReadLeShort();



			flags = inputBuffer.ReadLeShort();

			method = inputBuffer.ReadLeShort();

			uint dostime = (uint)inputBuffer.ReadLeInt();

			int crc2 = inputBuffer.ReadLeInt();

			csize = inputBuffer.ReadLeInt();

			size = inputBuffer.ReadLeInt();

			int nameLen = inputBuffer.ReadLeShort();

			int extraLen = inputBuffer.ReadLeShort();



			bool isCrypted = (flags & 1) == 1;



			byte[] buffer = new byte[nameLen];

			inputBuffer.ReadRawBuffer(buffer);



			string name = ZipConstants.ConvertToString(buffer);



			entry = new ZipEntry(name, versionRequiredToExtract);

			entry.Flags = flags;



			if (method == (int)CompressionMethod.Stored &&

			    (!isCrypted && csize != size ||

			     (isCrypted && csize - ZipConstants.CryptoHeaderSize != size)))

			{

				throw new ZipException("Stored, but compressed != uncompressed");

			}



			if (method != (int)CompressionMethod.Stored &&

			    method != (int)CompressionMethod.Deflated)

			{

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

			}



			entry.CompressionMethod = (CompressionMethod)method;



			if ((flags & 8) == 0)

			{

				entry.Crc = crc2 & 0xFFFFFFFFL;

				entry.Size = size & 0xFFFFFFFFL;

				entry.CompressedSize = csize & 0xFFFFFFFFL;

			}

			else

			{

				// This allows for GNU, WinZip and possibly other archives,

				// the PKZIP spec says these are zero under these circumstances.

				if (crc2 != 0)

				{

					entry.Crc = crc2 & 0xFFFFFFFFL;

				}



				if (size != 0)

				{

					entry.Size = size & 0xFFFFFFFFL;

				}

				if (csize != 0)

				{

					entry.CompressedSize = csize & 0xFFFFFFFFL;

				}

			}



			entry.DosTime = dostime;



			if (extraLen > 0)

			{

				byte[] extra = new byte[extraLen];

				inputBuffer.ReadRawBuffer(extra);

				entry.SetExtraData(extra);

			}



			internalReader = InitialRead;

			return entry;

		}

		#endregion



		#region CloseEntry (Public)

		/// <summary>

		/// Closes the current zip entry and moves to the next one.

		/// </summary>

		/// <exception cref="InvalidOperationException">

		/// The stream is closed

		/// </exception>

		/// <exception cref="ZipException">

		/// The Zip stream ends early

		/// </exception>

		public void CloseEntry()

		{

			if (crc == null)

			{

				throw new InvalidOperationException("Closed.");

			}



			if (entry == null)

			{

				return;

			}



			if (method == (int)CompressionMethod.Deflated)

			{

				if ((flags & 8) != 0)

				{

					// We don't know how much we must skip, read until end.

					byte[] tmp = new byte[2048];

					while (Read(tmp, 0, tmp.Length) > 0)

					{

						;

					}

					// read will close this entry

					return;

				}

				csize -= inf.TotalIn;

				inputBuffer.Available -= inf.RemainingInput;

			}



			if (inputBuffer.Available > csize && csize >= 0)

			{

				inputBuffer.Available = (int)(inputBuffer.Available - csize);

			}

			else

			{

				csize -= inputBuffer.Available;

				inputBuffer.Available = 0;

				while (csize != 0)

				{

					int skipped = (int)base.Skip(csize & 0xFFFFFFFFL);



					if (skipped <= 0)

					{

						throw new ZipException("Zip archive ends early.");

					}



					csize -= skipped;

				}

			}



			size = 0;

			crc.Reset();

			if (method == (int)CompressionMethod.Deflated)

			{

				inf.Reset();

			}

			entry = null;

		}

		#endregion



		#region ReadByte (Public)

		/// <summary>

		/// Reads a byte from the current zip entry.

		/// </summary>

		/// <returns>

		/// The byte or -1 if end of stream is reached.

		/// </returns>

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

		/// An i/o error occured.

		/// </exception>

		/// <exception name="Delta.Utilities.Compression.ZipException">

		/// The deflated stream is corrupted.

		/// </exception>

		public override int ReadByte()

		{

			byte[] b = new byte[1];

			if (Read(b, 0, 1) <= 0)

			{

				return MathHelper.InvalidIndex;

			}

			return b[0] & 0xff;

		}

		#endregion



		#region Read (Public)

		/// <summary>

		/// Read a block of bytes from the stream.

		/// </summary>

		/// <param name="buffer">The destination for the bytes.</param>

		/// <param name="offset">The index to start storing data.</param>

		/// <param name="count">The number of bytes to attempt to read.</param>

		/// <returns>Returns the number of bytes read.</returns>

		/// <remarks>Zero bytes read means end of stream.</remarks>

		public override int Read(byte[] buffer, int offset, int count)

		{

			return internalReader(buffer, offset, count);

		}

		#endregion



		#region BodyRead (Public)

		/// <summary>

		/// Reads a block of bytes from the current zip entry.

		/// </summary>

		/// <returns>

		/// The number of bytes read (this may be less than the length requested,

		/// even before the end of stream), or 0 on end of stream.

		/// </returns>

		/// <exception name="IOException">

		/// An i/o error occured.

		/// </exception>

		/// <exception cref="ZipException">

		/// The deflated stream is corrupted.

		/// </exception>

		/// <exception cref="InvalidOperationException">

		/// The stream is not open.

		/// </exception>

		public int BodyRead(byte[] b, int off, int len)

		{

			if (crc == null)

			{

				throw new InvalidOperationException("Closed.");

			}



			if (entry == null ||

			    len <= 0)

			{

				return 0;

			}



			bool finished = false;



			switch (method)

			{

				case (int)CompressionMethod.Deflated:

					len = base.Read(b, off, len);

					if (len <= 0)

					{

						if (inf.IsFinished == false)

						{

							throw new ZipException("Inflater not finished!?");

						}

						inputBuffer.Available = inf.RemainingInput;



						if ((flags & 8) == 0 &&

						    (inf.TotalIn != csize ||

						     inf.TotalOut != size))

						{

							throw new ZipException("size mismatch: " + csize + ";" + size +

							                       " <-> " + inf.TotalIn + ";" + inf.TotalOut);

						}

						inf.Reset();

						finished = true;

					}

					break;



				case (int)CompressionMethod.Stored:

					if (len > csize && csize >= 0)

					{

						len = (int)csize;

					}

					len = inputBuffer.ReadClearTextBuffer(b, off, len);

					if (len > 0)

					{

						csize -= len;

						size -= len;

					}



					if (csize == 0)

					{

						finished = true;

					}

					else

					{

						if (len < 0)

						{

							throw new ZipException("EOF in stored block");

						}

					}

					break;

			}



			if (len > 0)

			{

				crc.Update(b, off, len);

			}



			if (finished)

			{

				StopDecrypting();



				if ((flags & 8) != 0)

				{

					ReadDataDescriptor();

				}



				if ((crc.Value & 0xFFFFFFFFL) != entry.Crc &&

				    entry.Crc != MathHelper.InvalidIndex)

				{

					throw new ZipException("CRC mismatch");

				}

				crc.Reset();

				entry = null;

			}

			return len;

		}

		#endregion



		#region Close (Public)

		/// <summary>

		/// Closes the zip input stream

		/// </summary>

		public override void Close()

		{

			base.Close();

			crc = null;

			entry = null;

		}

		#endregion



		#region ExtractZipEntry (Public)

		/// <summary>

		/// Extract zip currentEntry

		/// </summary>

		/// <param name="zipEntry">Zip entry</param>

		/// <returns>Memory stream</returns>

		public MemoryStream ExtractZipEntry(ZipEntry zipEntry)

		{

			if (zipEntry == null)

			{

				throw new ArgumentNullException("entry",

					"ZipEntry must be valid");

			}



			// Max. length for reading a block of data: 4096

			// If we use a greater value we get errors like a lot of 0'str ..

			const int MaxReadBlockLength = 4096; //2048;

			int length = MaxReadBlockLength;

			byte[] data = new Byte[length];



			MemoryStream memStream = new MemoryStream();

			do

			{

				length = Read(data, 0, data.Length);

				if (length > 0)

				{

					memStream.Write(data, 0, length);

				}

			} while (length > 0);



			// Always go to beginning of stream for reading!

			memStream.Position = 0;

			return memStream;

		}

		#endregion



		#region Methods (Private)



		#region ReadDataDescriptor

		/// <summary>

		/// Read data descriptor at the end of compressed data.

		/// </summary>

		private void ReadDataDescriptor()

		{

			if (inputBuffer.ReadLeInt() != ZipConstants.ExternSig)

			{

				throw new ZipException("Data descriptor signature not found");

			}



			entry.Crc = inputBuffer.ReadLeInt() & 0xFFFFFFFFL;

			csize = inputBuffer.ReadLeInt();

			size = inputBuffer.ReadLeInt();



			entry.Size = size & 0xFFFFFFFFL;

			entry.CompressedSize = csize & 0xFFFFFFFFL;

		}

		#endregion



		#region InitialRead

		/// <summary>

		/// Perform the initial read on an entry which may include

		/// reading encryption headers and setting up inflation.

		/// </summary>

		/// <param name="destination">Destination</param>

		/// <param name="offset">Offset</param>

		/// <param name="count">Count</param>

		/// <returns>Int</returns>

		private int InitialRead(byte[] destination, int offset, int count)

		{

			if (entry.Version > ZipConstants.VersionMadeBy)

			{

				throw new ZipException(

					"Library cannot extract this entry version required (" +

					entry.Version.ToString() + ")");

			}



			// test for encryption

			if (entry.IsCrypted)

			{

				if (password == null)

				{

					throw new ZipException("No password set.");

				}



				// Generate and set crypto transform...

				ZipEncryptionManaged managed = new ZipEncryptionManaged();

				byte[] key = ZipEncryption.GenerateKeys(

					Encoding.ASCII.GetBytes(password));



				inputBuffer.CryptoTransform = managed.CreateDecryptor(key, null);



				byte[] cryptbuffer = new byte[ZipConstants.CryptoHeaderSize];

				inputBuffer.ReadClearTextBuffer(cryptbuffer, 0,

					ZipConstants.CryptoHeaderSize);



				if ((flags & 8) == 0)

				{

					if (cryptbuffer[ZipConstants.CryptoHeaderSize - 1] !=

					    (byte)(entry.Crc >> 24))

					{

						throw new ZipException("Invalid password");

					} // if

				} // if

				else

				{

					if (cryptbuffer[ZipConstants.CryptoHeaderSize - 1] !=

					    (byte)((entry.DosTime >> 8) & 0xff))

					{

						throw new ZipException("Invalid password");

					} // if

				} // else



				if (csize >= ZipConstants.CryptoHeaderSize)

				{

					csize -= ZipConstants.CryptoHeaderSize;

				} // if

			}

			else

			{

				inputBuffer.CryptoTransform = null;

			} // else



			if (method == (int)CompressionMethod.Deflated &&

			    inputBuffer.Available > 0)

			{

				inputBuffer.SetInflaterInput(inf);

			} // if



			internalReader = BodyRead;

			return BodyRead(destination, offset, count);

		}

		#endregion



		#endregion

	}

}