/Common/SharpZipLib/Zip/ZipConstants.cs

// ZipConstants.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.Text;

using System.Threading;



#if NETCF_1_0 || NETCF_2_0

using System.Globalization;

#endif



namespace SharpZipLib.Zip 

{



	#region Enumerations

	

	/// <summary>

	/// Determines how entries are tested to see if they should use Zip64 extensions or not.

	/// </summary>

	public enum UseZip64

	{

		/// <summary>

		/// Zip64 will not be forced on entries during processing.

		/// </summary>

		/// <remarks>An entry can have this overridden if required <see cref="ZipEntry.ForceZip64"></see></remarks>

		Off,

		/// <summary>

		/// Zip64 should always be used.

		/// </summary>

		On,

		/// <summary>

		/// #ZipLib will determine use based on entry values when added to archive.

		/// </summary>

		Dynamic,

	}

	

	/// <summary>

	/// The kind of compression used for an entry in an archive

	/// </summary>

	public enum CompressionMethod

	{

		/// <summary>

		/// A direct copy of the file contents is held in the archive

		/// </summary>

		Stored     = 0,

		

		/// <summary>

		/// Common Zip compression method using a sliding dictionary 

		/// of up to 32KB and secondary compression from Huffman/Shannon-Fano trees

		/// </summary>

		Deflated   = 8,

		

		/// <summary>

		/// An extension to deflate with a 64KB window. Not supported by #Zip currently

		/// </summary>

		Deflate64  = 9,

		

		/// <summary>

		/// BZip2 compression. Not supported by #Zip.

		/// </summary>

		BZip2      = 11,

		

		/// <summary>

		/// WinZip special for AES encryption, Not supported by #Zip.

		/// </summary>

		WinZipAES  = 99,

		

	}

	

	/// <summary>

	/// Identifies the encryption algorithm used for an entry

	/// </summary>

	public enum EncryptionAlgorithm

	{

		/// <summary>

		/// No encryption has been used.

		/// </summary>

		None           = 0,

		/// <summary>

		/// Encrypted using PKZIP 2.0 or 'classic' encryption.

		/// </summary>

		PkzipClassic   = 1,

		/// <summary>

		/// DES encryption has been used.

		/// </summary>

		Des            = 0x6601,

		/// <summary>

		/// RCS encryption has been used for encryption.

		/// </summary>

		RC2            = 0x6602,

		/// <summary>

		/// Triple DES encryption with 168 bit keys has been used for this entry.

		/// </summary>

		TripleDes168   = 0x6603,

		/// <summary>

		/// Triple DES with 112 bit keys has been used for this entry.

		/// </summary>

		TripleDes112   = 0x6609,

		/// <summary>

		/// AES 128 has been used for encryption.

		/// </summary>

		Aes128         = 0x660e,

		/// <summary>

		/// AES 192 has been used for encryption.

		/// </summary>

		Aes192         = 0x660f,

		/// <summary>

		/// AES 256 has been used for encryption.

		/// </summary>

		Aes256         = 0x6610,

		/// <summary>

		/// RC2 corrected has been used for encryption.

		/// </summary>

		RC2Corrected   = 0x6702,

		/// <summary>

		/// Blowfish has been used for encryption.

		/// </summary>

		Blowfish = 0x6720,

		/// <summary>

		/// Twofish has been used for encryption.

		/// </summary>

		Twofish = 0x6721,

		/// <summary>

		/// RC4 has been used for encryption.

		/// </summary>

		RC4            = 0x6801,

		/// <summary>

		/// An unknown algorithm has been used for encryption.

		/// </summary>

		Unknown        = 0xffff

	}



	/// <summary>

	/// Defines the contents of the general bit flags field for an archive entry.

	/// </summary>

	[Flags]

	public enum GeneralBitFlags : int

	{

		/// <summary>

		/// Bit 0 if set indicates that the file is encrypted

		/// </summary>

		Encrypted = 0x0001,

		/// <summary>

		/// Bits 1 and 2 - Two bits defining the compression method (only for Method 6 Imploding and 8,9 Deflating)

		/// </summary>

		Method = 0x0006,

		/// <summary>

		/// Bit 3 if set indicates a trailing data desciptor is appended to the entry data

		/// </summary>

		Descriptor = 0x0008,

		/// <summary>

		/// Bit 4 is reserved for use with method 8 for enhanced deflation

		/// </summary>

		ReservedPKware4 = 0x0010,

		/// <summary>

		/// Bit 5 if set indicates the file contains Pkzip compressed patched data.

		/// Requires version 2.7 or greater.

		/// </summary>

		Patched = 0x0020,

		/// <summary>

		/// Bit 6 if set strong encryption has been used for this entry.

		/// </summary>

		StrongEncryption = 0x0040,

		/// <summary>

		/// Bit 7 is currently unused

		/// </summary>

		Unused7 = 0x0080,

		/// <summary>

		/// Bit 8 is currently unused

		/// </summary>

		Unused8 = 0x0100,

		/// <summary>

		/// Bit 9 is currently unused

		/// </summary>

		Unused9 = 0x0200,

		/// <summary>

		/// Bit 10 is currently unused

		/// </summary>

		Unused10 = 0x0400,

		/// <summary>

		/// Bit 11 if set indicates the filename and 

		/// comment fields for this file must be encoded using UTF-8.

		/// </summary>

		UnicodeText = 0x0800,

		/// <summary>

		/// Bit 12 is documented as being reserved by PKware for enhanced compression.

		/// </summary>

		EnhancedCompress = 0x1000,

		/// <summary>

		/// Bit 13 if set indicates that values in the local header are masked to hide

		/// their actual values, and the central directory is encrypted.

		/// </summary>

		/// <remarks>

		/// Used when encrypting the central directory contents.

		/// </remarks>

		HeaderMasked = 0x2000,

		/// <summary>

		/// Bit 14 is documented as being reserved for use by PKware

		/// </summary>

		ReservedPkware14 = 0x4000,

		/// <summary>

		/// Bit 15 is documented as being reserved for use by PKware

		/// </summary>

		ReservedPkware15 = 0x8000

	}

	

	#endregion



	/// <summary>

	/// This class contains constants used for Zip format files

	/// </summary>

	public sealed class ZipConstants

	{

		#region Versions

		/// <summary>

		/// The version made by field for entries in the central header when created by this library

		/// </summary>

		/// <remarks>

		/// This is also the Zip version for the library when comparing against the version required to extract

		/// for an entry.  See <see cref="ZipEntry.CanDecompress"/>.

		/// </remarks>

		public const int VersionMadeBy = 45;

		

		/// <summary>

		/// The version made by field for entries in the central header when created by this library

		/// </summary>

		/// <remarks>

		/// This is also the Zip version for the library when comparing against the version required to extract

		/// for an entry.  See <see cref="ZipInputStream.CanDecompressEntry">ZipInputStream.CanDecompressEntry</see>.

		/// </remarks>

		[Obsolete("Use VersionMadeBy instead")]

		public const int VERSION_MADE_BY = 45;

		

		/// <summary>

		/// The minimum version required to support strong encryption

		/// </summary>

		public const int VersionStrongEncryption = 50;



		/// <summary>

		/// The minimum version required to support strong encryption

		/// </summary>

		[Obsolete("Use VersionStrongEncryption instead")]

		public const int VERSION_STRONG_ENCRYPTION = 50;

		

		/// <summary>

		/// The version required for Zip64 extensions

		/// </summary>

		public const int VersionZip64 = 45;

		#endregion

		

		#region Header Sizes

		/// <summary>

		/// Size of local entry header (excluding variable length fields at end)

		/// </summary>

		public const int LocalHeaderBaseSize = 30;

		

		/// <summary>

		/// Size of local entry header (excluding variable length fields at end)

		/// </summary>

		[Obsolete("Use LocalHeaderBaseSize instead")]

		public const int LOCHDR = 30;

		

		/// <summary>

		/// Size of Zip64 data descriptor

		/// </summary>

		public const int Zip64DataDescriptorSize = 24;

		

		/// <summary>

		/// Size of data descriptor

		/// </summary>

		public const int DataDescriptorSize = 16;

		

		/// <summary>

		/// Size of data descriptor

		/// </summary>

		[Obsolete("Use DataDescriptorSize instead")]

		public const int EXTHDR = 16;

		

		/// <summary>

		/// Size of central header entry (excluding variable fields)

		/// </summary>

		public const int CentralHeaderBaseSize = 46;

		

		/// <summary>

		/// Size of central header entry

		/// </summary>

		[Obsolete("Use CentralHeaderBaseSize instead")]

		public const int CENHDR = 46;

		

		/// <summary>

		/// Size of end of central record (excluding variable fields)

		/// </summary>

		public const int EndOfCentralRecordBaseSize = 22;

		

		/// <summary>

		/// Size of end of central record (excluding variable fields)

		/// </summary>

		[Obsolete("Use EndOfCentralRecordBaseSize instead")]

		public const int ENDHDR = 22;

		

		/// <summary>

		/// Size of 'classic' cryptographic header stored before any entry data

		/// </summary>

		public const int CryptoHeaderSize = 12;

		

		/// <summary>

		/// Size of cryptographic header stored before entry data

		/// </summary>

		[Obsolete("Use CryptoHeaderSize instead")]

		public const int CRYPTO_HEADER_SIZE = 12;

		#endregion

		

		#region Header Signatures

		

		/// <summary>

		/// Signature for local entry header

		/// </summary>

		public const int LocalHeaderSignature = 'P' | ('K' << 8) | (3 << 16) | (4 << 24);



		/// <summary>

		/// Signature for local entry header

		/// </summary>

		[Obsolete("Use LocalHeaderSignature instead")]

		public const int LOCSIG = 'P' | ('K' << 8) | (3 << 16) | (4 << 24);



		/// <summary>

		/// Signature for spanning entry

		/// </summary>

		public const int SpanningSignature = 'P' | ('K' << 8) | (7 << 16) | (8 << 24);

		

		/// <summary>

		/// Signature for spanning entry

		/// </summary>

		[Obsolete("Use SpanningSignature instead")]

		public const int SPANNINGSIG = 'P' | ('K' << 8) | (7 << 16) | (8 << 24);

		

		/// <summary>

		/// Signature for temporary spanning entry

		/// </summary>

		public const int SpanningTempSignature = 'P' | ('K' << 8) | ('0' << 16) | ('0' << 24);

		

		/// <summary>

		/// Signature for temporary spanning entry

		/// </summary>

		[Obsolete("Use SpanningTempSignature instead")]

		public const int SPANTEMPSIG = 'P' | ('K' << 8) | ('0' << 16) | ('0' << 24);

		

		/// <summary>

		/// Signature for data descriptor

		/// </summary>

		/// <remarks>

		/// This is only used where the length, Crc, or compressed size isnt known when the

		/// entry is created and the output stream doesnt support seeking.

		/// The local entry cannot be 'patched' with the correct values in this case

		/// so the values are recorded after the data prefixed by this header, as well as in the central directory.

		/// </remarks>

		public const int DataDescriptorSignature = 'P' | ('K' << 8) | (7 << 16) | (8 << 24);

		

		/// <summary>

		/// Signature for data descriptor

		/// </summary>

		/// <remarks>

		/// This is only used where the length, Crc, or compressed size isnt known when the

		/// entry is created and the output stream doesnt support seeking.

		/// The local entry cannot be 'patched' with the correct values in this case

		/// so the values are recorded after the data prefixed by this header, as well as in the central directory.

		/// </remarks>

		[Obsolete("Use DataDescriptorSignature instead")]

		public const int EXTSIG = 'P' | ('K' << 8) | (7 << 16) | (8 << 24);

		

		/// <summary>

		/// Signature for central header

		/// </summary>

		[Obsolete("Use CentralHeaderSignature instead")]

		public const int CENSIG = 'P' | ('K' << 8) | (1 << 16) | (2 << 24);



		/// <summary>

		/// Signature for central header

		/// </summary>

		public const int CentralHeaderSignature = 'P' | ('K' << 8) | (1 << 16) | (2 << 24);



		/// <summary>

		/// Signature for Zip64 central file header

		/// </summary>

		public const int Zip64CentralFileHeaderSignature = 'P' | ('K' << 8) | (6 << 16) | (6 << 24);

		

		/// <summary>

		/// Signature for Zip64 central file header

		/// </summary>

		[Obsolete("Use Zip64CentralFileHeaderSignature instead")]

		public const int CENSIG64 = 'P' | ('K' << 8) | (6 << 16) | (6 << 24);

		

		/// <summary>

		/// Signature for Zip64 central directory locator

		/// </summary>

		public const int Zip64CentralDirLocatorSignature = 'P' | ('K' << 8) | (6 << 16) | (7 << 24);

		

		/// <summary>

		/// Signature for archive extra data signature (were headers are encrypted).

		/// </summary>

		public const int ArchiveExtraDataSignature = 'P' | ('K' << 8) | (6 << 16) | (7 << 24);

		

		/// <summary>

		/// Central header digitial signature

		/// </summary>

		public const int CentralHeaderDigitalSignature = 'P' | ('K' << 8) | (5 << 16) | (5 << 24);

		

		/// <summary>

		/// Central header digitial signature

		/// </summary>

		[Obsolete("Use CentralHeaderDigitalSignaure instead")]

		public const int CENDIGITALSIG = 'P' | ('K' << 8) | (5 << 16) | (5 << 24);



		/// <summary>

		/// End of central directory record signature

		/// </summary>

		public const int EndOfCentralDirectorySignature = 'P' | ('K' << 8) | (5 << 16) | (6 << 24);

		

		/// <summary>

		/// End of central directory record signature

		/// </summary>

		[Obsolete("Use EndOfCentralDirectorySignature instead")]

		public const int ENDSIG = 'P' | ('K' << 8) | (5 << 16) | (6 << 24);

		#endregion

		

#if NETCF_1_0 || NETCF_2_0

		// This isnt so great but is better than nothing.

        // Trying to work out an appropriate OEM code page would be good.

        // 850 is a good default for english speakers particularly in Europe.

		static int defaultCodePage = CultureInfo.CurrentCulture.TextInfo.ANSICodePage;

#else

		static int defaultCodePage = Thread.CurrentThread.CurrentCulture.TextInfo.OEMCodePage;

#endif

		

		/// <summary>

		/// Default encoding used for string conversion.  0 gives the default system OEM code page.

		/// Dont use unicode encodings if you want to be Zip compatible!

		/// Using the default code page isnt the full solution neccessarily

		/// there are many variable factors, codepage 850 is often a good choice for

		/// European users, however be careful about compatability.

		/// </summary>

		public static int DefaultCodePage {

			get {

				return defaultCodePage; 

			}

			set {

				defaultCodePage = value; 

			}

		}



		/// <summary>

		/// Convert a portion of a byte array to a string.

		/// </summary>		

		/// <param name="data">

		/// Data to convert to string

		/// </param>

		/// <param name="count">

		/// Number of bytes to convert starting from index 0

		/// </param>

		/// <returns>

		/// data[0]..data[length - 1] converted to a string

		/// </returns>

		public static string ConvertToString(byte[] data, int count)

		{

			if ( data == null ) {

				return string.Empty;	

			}

			

			return Encoding.GetEncoding(DefaultCodePage).GetString(data, 0, count);

		}

	

		/// <summary>

		/// Convert a byte array to string

		/// </summary>

		/// <param name="data">

		/// Byte array to convert

		/// </param>

		/// <returns>

		/// <paramref name="data">data</paramref>converted to a string

		/// </returns>

		public static string ConvertToString(byte[] data)

		{

			if ( data == null ) {

				return string.Empty;	

			}

			return ConvertToString(data, data.Length);

		}



		/// <summary>

		/// Convert a byte array to string

		/// </summary>

		/// <param name="flags">The applicable general purpose bits flags</param>

		/// <param name="data">

		/// Byte array to convert

		/// </param>

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

		/// <returns>

		/// <paramref name="data">data</paramref>converted to a string

		/// </returns>

		public static string ConvertToStringExt(int flags, byte[] data, int count)

		{

			if ( data == null ) {

				return string.Empty;	

			}

			

			if ( (flags & (int)GeneralBitFlags.UnicodeText) != 0 ) {

				return Encoding.UTF8.GetString(data, 0, count);

			}

			else {

				return ConvertToString(data, count);

			}

		}

		

		/// <summary>

		/// Convert a byte array to string

		/// </summary>

		/// <param name="data">

		/// Byte array to convert

		/// </param>

		/// <param name="flags">The applicable general purpose bits flags</param>

		/// <returns>

		/// <paramref name="data">data</paramref>converted to a string

		/// </returns>

		public static string ConvertToStringExt(int flags, byte[] data)

		{

			if ( data == null ) {

				return string.Empty;	

			}

			

			if ( (flags & (int)GeneralBitFlags.UnicodeText) != 0 ) {

				return Encoding.UTF8.GetString(data, 0, data.Length);

			}

			else {

				return ConvertToString(data, data.Length);

			}

		}



		/// <summary>

		/// Convert a string to a byte array

		/// </summary>

		/// <param name="str">

		/// String to convert to an array

		/// </param>

		/// <returns>Converted array</returns>

		public static byte[] ConvertToArray(string str)

		{

			if ( str == null ) {

				return new byte[0];

			}

			

			return Encoding.GetEncoding(DefaultCodePage).GetBytes(str);

		}



		/// <summary>

		/// Convert a string to a byte array

		/// </summary>

        /// <param name="flags">The applicable <see cref="GeneralBitFlags">general purpose bits flags</see></param>

		/// <param name="str">

		/// String to convert to an array

		/// </param>

		/// <returns>Converted array</returns>

		public static byte[] ConvertToArray(int flags, string str)

		{

			if (str == null) {

				return new byte[0];

			}



			if ((flags & (int)GeneralBitFlags.UnicodeText) != 0) {

				return Encoding.UTF8.GetBytes(str);

			}

			else {

				return ConvertToArray(str);

			}

		}



		

		/// <summary>

		/// Initialise default instance of <see cref="ZipConstants">ZipConstants</see>

		/// </summary>

		/// <remarks>

		/// Private to prevent instances being created.

		/// </remarks>

		ZipConstants()

		{

			// Do nothing

		}

	}

}