root/trunk/BazaReklam.Updater/ICSharpCode.SharpZipLib/Zip/ZipHelperStream.cs @ 609

// ZipHelperStream.cs
//
// Copyright 2006, 2007 John Reilly
//
// 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.IO;
using System.Text;

namespace ICSharpCode.SharpZipLib.Zip
{

        /// <summary>
        /// Holds data pertinent to a data descriptor.
        /// </summary>
        public class DescriptorData
        {
                /// <summary>
                /// Get /set the compressed size of data.
                /// </summary>
                public long CompressedSize
                {
                        get { return compressedSize; }
                        set { compressedSize = value; }
                }

                /// <summary>
                /// Get / set the uncompressed size of data
                /// </summary>
                public long Size
                {
                        get { return size; }
                        set { size = value; }
                }

                /// <summary>
                /// Get /set the crc value.
                /// </summary>
                public long Crc
                {
                        get { return crc; }
                        set { crc = (value & 0xffffffff); }
                }

                #region Instance Fields
                long size;
                long compressedSize;
                long crc;
                #endregion
        }

        class EntryPatchData
        {
                public long SizePatchOffset
                {
                        get { return sizePatchOffset_; }
                        set { sizePatchOffset_ = value; }
                }

                public long CrcPatchOffset
                {
                        get { return crcPatchOffset_; }
                        set { crcPatchOffset_ = value; }
                }
                
                #region Instance Fields
                long sizePatchOffset_;
                long crcPatchOffset_;
                #endregion
        }
        
        /// <summary>
        /// This class assists with writing/reading from Zip files.
        /// </summary>
        internal class ZipHelperStream : Stream
        {
                #region Constructors
                /// <summary>
                /// Initialise an instance of this class.
                /// </summary>
                /// <param name="name">The name of the file to open.</param>
                public ZipHelperStream(string name)
                {
                        stream_ = new FileStream(name, FileMode.Open, FileAccess.ReadWrite);
                        isOwner_ = true;
                }

                /// <summary>
                /// Initialise a new instance of <see cref="ZipHelperStream"/>.
                /// </summary>
                /// <param name="stream">The stream to use.</param>
                public ZipHelperStream(Stream stream)
                {
                        stream_ = stream;
                }
                #endregion

                /// <summary>
                /// Get / set a value indicating wether the the underlying stream is owned or not.
                /// </summary>
                /// <remarks>If the stream is owned it is closed when this instance is closed.</remarks>
                public bool IsStreamOwner
                {
                        get { return isOwner_; }
                        set { isOwner_ = value; }
                }

                #region Base Stream Methods
                public override bool CanRead
                {
                        get { return stream_.CanRead; }
                }

                public override bool CanSeek
                {
                        get { return stream_.CanSeek; }
                }

#if !NET_1_0 && !NET_1_1 && !NETCF_1_0
                public override bool CanTimeout
                {
                        get { return stream_.CanTimeout; }
                }
#endif

                public override long Length
                {
                        get { return stream_.Length; }
                }

                public override long Position
                {
                        get { return stream_.Position; }
                        set { stream_.Position = value; }
                }

                public override bool CanWrite
                {
                        get { return stream_.CanWrite; }
                }

                public override void Flush()
                {
                        stream_.Flush();
                }

                public override long Seek(long offset, SeekOrigin origin)
                {
                        return stream_.Seek(offset, origin);
                }

                public override void SetLength(long value)
                {
                        stream_.SetLength(value);
                }

                public override int Read(byte[] buffer, int offset, int count)
                {
                        return stream_.Read(buffer, offset, count);
                }

                public override void Write(byte[] buffer, int offset, int count)
                {
                        stream_.Write(buffer, offset, count);
                }

                /// <summary>
                /// Close the stream.
                /// </summary>
                /// <remarks>
                /// The underlying stream is closed only if <see cref="IsStreamOwner"/> is true.
                /// </remarks>
                override public void Close()
                {
                        Stream toClose = stream_;
                        stream_ = null;
                        if (isOwner_ && (toClose != null))
                        {
                                isOwner_ = false;
                                toClose.Close();
                        }
                }
                #endregion
                
                // Write the local file header
                // TODO: ZipHelperStream.WriteLocalHeader is not yet used and needs checking for ZipFile and ZipOuptutStream usage
                void WriteLocalHeader(ZipEntry entry, EntryPatchData patchData) 
                {
                        CompressionMethod method = entry.CompressionMethod;
                        bool headerInfoAvailable = true; // How to get this?
                        bool patchEntryHeader = false;

                        WriteLEInt(ZipConstants.LocalHeaderSignature);
                        
                        WriteLEShort(entry.Version);
                        WriteLEShort(entry.Flags);
                        WriteLEShort((byte)method);
                        WriteLEInt((int)entry.DosTime);

                        if (headerInfoAvailable == true) {
                                WriteLEInt((int)entry.Crc);
                                if ( entry.LocalHeaderRequiresZip64 ) {
                                        WriteLEInt(-1);
                                        WriteLEInt(-1);
                                }
                                else {
                                        WriteLEInt(entry.IsCrypted ? (int)entry.CompressedSize + ZipConstants.CryptoHeaderSize : (int)entry.CompressedSize);
                                        WriteLEInt((int)entry.Size);
                                }
                        } else {
                                if (patchData != null) {
                                        patchData.CrcPatchOffset = stream_.Position;
                                }
                                WriteLEInt(0);  // Crc
                                
                                if ( patchData != null ) {
                                        patchData.SizePatchOffset = stream_.Position;
                                }

                                // For local header both sizes appear in Zip64 Extended Information
                                if ( entry.LocalHeaderRequiresZip64 && patchEntryHeader ) {
                                        WriteLEInt(-1);
                                        WriteLEInt(-1);
                                }
                                else {
                                        WriteLEInt(0);  // Compressed size
                                        WriteLEInt(0);  // Uncompressed size
                                }
                        }

                        byte[] name = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
                        
                        if (name.Length > 0xFFFF) {
                                throw new ZipException("Entry name too long.");
                        }

                        ZipExtraData ed = new ZipExtraData(entry.ExtraData);

                        if (entry.LocalHeaderRequiresZip64 && (headerInfoAvailable || patchEntryHeader)) {
                                ed.StartNewEntry();
                                if (headerInfoAvailable) {
                                        ed.AddLeLong(entry.Size);
                                        ed.AddLeLong(entry.CompressedSize);
                                }
                                else {
                                        ed.AddLeLong(-1);
                                        ed.AddLeLong(-1);
                                }
                                ed.AddNewEntry(1);

                                if ( !ed.Find(1) ) {
                                        throw new ZipException("Internal error cant find extra data");
                                }
                                
                                if ( patchData != null ) {
                                        patchData.SizePatchOffset = ed.CurrentReadIndex;
                                }
                        }
                        else {
                                ed.Delete(1);
                        }
                        
                        byte[] extra = ed.GetEntryData();

                        WriteLEShort(name.Length);
                        WriteLEShort(extra.Length);

                        if ( name.Length > 0 ) {
                                stream_.Write(name, 0, name.Length);
                        }
                        
                        if ( entry.LocalHeaderRequiresZip64 && patchEntryHeader ) {
                                patchData.SizePatchOffset += stream_.Position;
                        }

                        if ( extra.Length > 0 ) {
                                stream_.Write(extra, 0, extra.Length);
                        }
                }
        
                /// <summary>
                /// Locates a block with the desired <paramref name="signature"/>.
                /// </summary>
                /// <param name="signature">The signature to find.</param>
                /// <param name="endLocation">Location, marking the end of block.</param>
                /// <param name="minimumBlockSize">Minimum size of the block.</param>
                /// <param name="maximumVariableData">The maximum variable data.</param>
                /// <returns>Eeturns the offset of the first byte after the signature; -1 if not found</returns>
                public long LocateBlockWithSignature(int signature, long endLocation, int minimumBlockSize, int maximumVariableData)
                {
                        long pos = endLocation - minimumBlockSize;
                        if ( pos < 0 ) {
                                return -1;
                        }

                        long giveUpMarker = Math.Max(pos - maximumVariableData, 0);

                        // TODO: This loop could be optimised for speed.
                        do {
                                if ( pos < giveUpMarker ) {
                                        return -1;
                                }
                                Seek(pos--, SeekOrigin.Begin);
                        } while ( ReadLEInt() != signature );

                        return Position;
                }

                /// <summary>
                /// Write Zip64 end of central directory records (File header and locator).
                /// </summary>
                /// <param name="noOfEntries">The number of entries in the central directory.</param>
                /// <param name="sizeEntries">The size of entries in the central directory.</param>
                /// <param name="centralDirOffset">The offset of the dentral directory.</param>
                public void WriteZip64EndOfCentralDirectory(long noOfEntries, long sizeEntries, long centralDirOffset)
                {
                        long centralSignatureOffset = stream_.Position;
                        WriteLEInt(ZipConstants.Zip64CentralFileHeaderSignature);
                        WriteLELong(44);    // Size of this record (total size of remaining fields in header or full size - 12)
                        WriteLEShort(ZipConstants.VersionMadeBy);   // Version made by
                        WriteLEShort(ZipConstants.VersionZip64);   // Version to extract
                        WriteLEInt(0);      // Number of this disk
                        WriteLEInt(0);      // number of the disk with the start of the central directory
                        WriteLELong(noOfEntries);       // No of entries on this disk
                        WriteLELong(noOfEntries);       // Total No of entries in central directory
                        WriteLELong(sizeEntries);       // Size of the central directory
                        WriteLELong(centralDirOffset);  // offset of start of central directory
                        // zip64 extensible data sector not catered for here (variable size)

                        // Write the Zip64 end of central directory locator
                        WriteLEInt(ZipConstants.Zip64CentralDirLocatorSignature);

                        // no of the disk with the start of the zip64 end of central directory
                        WriteLEInt(0);

                        // relative offset of the zip64 end of central directory record
                        WriteLELong(centralSignatureOffset);

                        // total number of disks
                        WriteLEInt(1);
                }

                /// <summary>
                /// Write the required records to end the central directory.
                /// </summary>
                /// <param name="noOfEntries">The number of entries in the directory.</param>
                /// <param name="sizeEntries">The size of the entries in the directory.</param>
                /// <param name="startOfCentralDirectory">The start of the central directory.</param>
                /// <param name="comment">The archive comment.  (This can be null).</param>
                public void WriteEndOfCentralDirectory(long noOfEntries, long sizeEntries,
                        long startOfCentralDirectory, byte[] comment)
                {

                        if ( (noOfEntries >= 0xffff) ||
                                (startOfCentralDirectory >= 0xffffffff) ||
                                (sizeEntries >= 0xffffffff) ) {
                                WriteZip64EndOfCentralDirectory(noOfEntries, sizeEntries, startOfCentralDirectory);
                        }

                        WriteLEInt(ZipConstants.EndOfCentralDirectorySignature);

                        // TODO: ZipFile Multi disk handling not done
                        WriteLEShort(0);                    // number of this disk
                        WriteLEShort(0);                    // no of disk with start of central dir

                        
                        // Number of entries
                        if ( noOfEntries >= 0xffff ) {
                                WriteLEUshort(0xffff);  // Zip64 marker
                                WriteLEUshort(0xffff);
                        }
                        else {
                                WriteLEShort(( short )noOfEntries);          // entries in central dir for this disk
                                WriteLEShort(( short )noOfEntries);          // total entries in central directory
                        }

                        // Size of the central directory
                        if ( sizeEntries >= 0xffffffff ) {
                                WriteLEUint(0xffffffff);    // Zip64 marker
                        }
                        else {
                                WriteLEInt(( int )sizeEntries);            
                        }


                        // offset of start of central directory
                        if ( startOfCentralDirectory >= 0xffffffff ) {
                                WriteLEUint(0xffffffff);    // Zip64 marker
                        }
                        else {
                                WriteLEInt(( int )startOfCentralDirectory);
                        }

                        int commentLength = (comment != null) ? comment.Length : 0;

                        if ( commentLength > 0xffff ) {
                                throw new ZipException(string.Format("Comment length({0}) is too long can only be 64K", commentLength));
                        }

                        WriteLEShort(commentLength);

                        if ( commentLength > 0 ) {
                                Write(comment, 0, comment.Length);
                        }
                }

                #region LE value reading/writing
                /// <summary>
                /// Read an unsigned short in little endian byte order.
                /// </summary>
                /// <returns>Returns the value read.</returns>
                /// <exception cref="IOException">
                /// An i/o error occurs.
                /// </exception>
                /// <exception cref="EndOfStreamException">
                /// The file ends prematurely
                /// </exception>
                public int ReadLEShort()
                {
                        int byteValue1 = stream_.ReadByte();

                        if (byteValue1 < 0) {
                                throw new EndOfStreamException();
                        }

                        int byteValue2 = stream_.ReadByte();
                        if (byteValue2 < 0) {
                                throw new EndOfStreamException();
                        }

                        return byteValue1 | (byteValue2 << 8);
                }

                /// <summary>
                /// Read an int in little endian byte order.
                /// </summary>
                /// <returns>Returns the value read.</returns>
                /// <exception cref="IOException">
                /// An i/o error occurs.
                /// </exception>
                /// <exception cref="System.IO.EndOfStreamException">
                /// The file ends prematurely
                /// </exception>
                public int ReadLEInt()
                {
                        return ReadLEShort() | (ReadLEShort() << 16);
                }

                /// <summary>
                /// Read a long in little endian byte order.
                /// </summary>
                /// <returns>The value read.</returns>
                public long ReadLELong()
                {
                        return (uint)ReadLEInt() | ((long)ReadLEInt() << 32);
                }

                /// <summary>
                /// Write an unsigned short in little endian byte order.
                /// </summary>
                /// <param name="value">The value to write.</param>
                public void WriteLEShort(int value)
                {
                        stream_.WriteByte(( byte )(value & 0xff));
                        stream_.WriteByte(( byte )((value >> 8) & 0xff));
                }

                /// <summary>
                /// Write a ushort in little endian byte order.
                /// </summary>
                /// <param name="value">The value to write.</param>
                public void WriteLEUshort(ushort value)
                {
                        stream_.WriteByte(( byte )(value & 0xff));
                        stream_.WriteByte(( byte )(value >> 8));
                }

                /// <summary>
                /// Write an int in little endian byte order.
                /// </summary>
                /// <param name="value">The value to write.</param>
                public void WriteLEInt(int value)
                {
                        WriteLEShort(value);
                        WriteLEShort(value >> 16);
                }

                /// <summary>
                /// Write a uint in little endian byte order.
                /// </summary>
                /// <param name="value">The value to write.</param>
                public void WriteLEUint(uint value)
                {
                        WriteLEUshort(( ushort )(value & 0xffff));
                        WriteLEUshort(( ushort )(value >> 16));
                }

                /// <summary>
                /// Write a long in little endian byte order.
                /// </summary>
                /// <param name="value">The value to write.</param>
                public void WriteLELong(long value)
                {
                        WriteLEInt(( int )value);
                        WriteLEInt(( int )(value >> 32));
                }

                /// <summary>
                /// Write a ulong in little endian byte order.
                /// </summary>
                /// <param name="value">The value to write.</param>
                public void WriteLEUlong(ulong value)
                {
                        WriteLEUint(( uint )(value & 0xffffffff));
                        WriteLEUint(( uint )(value >> 32));
                }

                #endregion

                /// <summary>
                /// Write a data descriptor.
                /// </summary>
                /// <param name="entry">The entry to write a descriptor for.</param>
                /// <returns>Returns the number of descriptor bytes written.</returns>
                public int WriteDataDescriptor(ZipEntry entry)
                {
                        if (entry == null) {
                                throw new ArgumentNullException("entry");
                        }

                        int result=0;

                        // Add data descriptor if flagged as required
                        if ((entry.Flags & (int)GeneralBitFlags.Descriptor) != 0)
                        {
                                // The signature is not PKZIP originally but is now described as optional
                                // in the PKZIP Appnote documenting trhe format.
                                WriteLEInt(ZipConstants.DataDescriptorSignature);
                                WriteLEInt(unchecked((int)(entry.Crc)));

                                result+=8;

                                if (entry.LocalHeaderRequiresZip64)
                                {
                                        WriteLELong(entry.CompressedSize);
                                        WriteLELong(entry.Size);
                                        result+=16;
                                }
                                else
                                {
                                        WriteLEInt((int)entry.CompressedSize);
                                        WriteLEInt((int)entry.Size);
                                        result+=8;
                                }
                        }

                        return result;
                }

                /// <summary>
                /// Read data descriptor at the end of compressed data.
                /// </summary>
                /// <param name="zip64">if set to <c>true</c> [zip64].</param>
                /// <param name="data">The data to fill in.</param>
                /// <returns>Returns the number of bytes read in the descriptor.</returns>
                public void ReadDataDescriptor(bool zip64, DescriptorData data)
                {
                        int intValue = ReadLEInt();

                        // In theory this may not be a descriptor according to PKZIP appnote.
                        // In practise its always there.
                        if (intValue != ZipConstants.DataDescriptorSignature) {
                                throw new ZipException("Data descriptor signature not found");
                        }

                        data.Crc = ReadLEInt();
                        
                        if (zip64) {
                                data.CompressedSize = ReadLELong();
                                data.Size = ReadLELong();
                        }
                        else {
                                data.CompressedSize = ReadLEInt();
                                data.Size = ReadLEInt();
                        }
                }

                #region Instance Fields
                bool isOwner_;
                Stream stream_;
                #endregion
        }
}