apewer-dotnet/Apewer/Externals/Compression/Zip/ZipExtraData.cs

//
// ZipExtraData.cs
//
// Copyright 2004-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;

namespace Externals.Compression.Zip
{
    // TODO: Sort out wether tagged data is useful and what a good implementation might look like.
    // Its just a sketch of an idea at the moment.

    /// <summary>
    /// ExtraData tagged value interface.
    /// </summary>
    internal interface ITaggedData
    {
        /// <summary>
        /// Get the ID for this tagged data value.
        /// </summary>
        short TagID { get; }

        /// <summary>
        /// Set the contents of this instance from the data passed.
        /// </summary>
        /// <param name="data">The data to extract contents from.</param>
        /// <param name="offset">The offset to begin extracting data from.</param>
        /// <param name="count">The number of bytes to extract.</param>
        void SetData(byte[] data, int offset, int count);

        /// <summary>
        /// Get the data representing this instance.
        /// </summary>
        /// <returns>Returns the data for this instance.</returns>
        byte[] GetData();
    }

    /// <summary>
    /// A raw binary tagged value
    /// </summary>
    internal class RawTaggedData : ITaggedData
    {
        /// <summary>
        /// Initialise a new instance.
        /// </summary>
        /// <param name="tag">The tag ID.</param>
        public RawTaggedData(short tag)
        {
            _tag = tag;
        }

        #region ITaggedData Members

        /// <summary>
        /// Get the ID for this tagged data value.
        /// </summary>
        public short TagID
        {
            get { return _tag; }
            set { _tag = value; }
        }

        /// <summary>
        /// Set the data from the raw values provided.
        /// </summary>
        /// <param name="data">The raw data to extract values from.</param>
        /// <param name="offset">The index to start extracting values from.</param>
        /// <param name="count">The number of bytes available.</param>
        public void SetData(byte[] data, int offset, int count)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }

            _data = new byte[count];
            Array.Copy(data, offset, _data, 0, count);
        }

        /// <summary>
        /// Get the binary data representing this instance.
        /// </summary>
        /// <returns>The raw binary data representing this instance.</returns>
        public byte[] GetData()
        {
            return _data;
        }

        #endregion

        /// <summary>
        /// Get /set the binary data representing this instance.
        /// </summary>
        /// <returns>The raw binary data representing this instance.</returns>
        public byte[] Data
        {
            get { return _data; }
            set { _data = value; }
        }

        #region Instance Fields
        /// <summary>
        /// The tag ID for this instance.
        /// </summary>
        short _tag;

        byte[] _data;
        #endregion
    }

    /// <summary>
    /// Class representing extended unix date time values.
    /// </summary>
    internal class ExtendedUnixData : ITaggedData
    {
        /// <summary>
        /// Flags indicate which values are included in this instance.
        /// </summary>
        [Flags]
        internal enum Flags : byte
        {
            /// <summary>
            /// The modification time is included
            /// </summary>
            ModificationTime = 0x01,

            /// <summary>
            /// The access time is included
            /// </summary>
            AccessTime = 0x02,

            /// <summary>
            /// The create time is included.
            /// </summary>
            CreateTime = 0x04,
        }

        #region ITaggedData Members

        /// <summary>
        /// Get the ID
        /// </summary>
        public short TagID
        {
            get { return 0x5455; }
        }

        /// <summary>
        /// Set the data from the raw values provided.
        /// </summary>
        /// <param name="data">The raw data to extract values from.</param>
        /// <param name="index">The index to start extracting values from.</param>
        /// <param name="count">The number of bytes available.</param>
        public void SetData(byte[] data, int index, int count)
        {
            using (MemoryStream ms = new MemoryStream(data, index, count, false))
            using (ZipHelperStream helperStream = new ZipHelperStream(ms))
            {
                // bit 0           if set, modification time is present
                // bit 1           if set, access time is present
                // bit 2           if set, creation time is present

                _flags = (Flags)helperStream.ReadByte();
                if (((_flags & Flags.ModificationTime) != 0) && (count >= 5))
                {
                    int iTime = helperStream.ReadLEInt();

                    _modificationTime = (new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() +
                        new TimeSpan(0, 0, 0, iTime, 0)).ToLocalTime();
                }

                if ((_flags & Flags.AccessTime) != 0)
                {
                    int iTime = helperStream.ReadLEInt();

                    _lastAccessTime = (new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() +
                        new TimeSpan(0, 0, 0, iTime, 0)).ToLocalTime();
                }

                if ((_flags & Flags.CreateTime) != 0)
                {
                    int iTime = helperStream.ReadLEInt();

                    _createTime = (new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() +
                        new TimeSpan(0, 0, 0, iTime, 0)).ToLocalTime();
                }
            }
        }

        /// <summary>
        /// Get the binary data representing this instance.
        /// </summary>
        /// <returns>The raw binary data representing this instance.</returns>
        public byte[] GetData()
        {
            using (MemoryStream ms = new MemoryStream())
            using (ZipHelperStream helperStream = new ZipHelperStream(ms))
            {
                helperStream.IsStreamOwner = false;
                helperStream.WriteByte((byte)_flags);     // Flags
                if ((_flags & Flags.ModificationTime) != 0)
                {
                    TimeSpan span = _modificationTime.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime();
                    int seconds = (int)span.TotalSeconds;
                    helperStream.WriteLEInt(seconds);
                }
                if ((_flags & Flags.AccessTime) != 0)
                {
                    TimeSpan span = _lastAccessTime.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime();
                    int seconds = (int)span.TotalSeconds;
                    helperStream.WriteLEInt(seconds);
                }
                if ((_flags & Flags.CreateTime) != 0)
                {
                    TimeSpan span = _createTime.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime();
                    int seconds = (int)span.TotalSeconds;
                    helperStream.WriteLEInt(seconds);
                }
                return ms.ToArray();
            }
        }

        #endregion

        /// <summary>
        /// Test a <see cref="DateTime"> value to see if is valid and can be represented here.</see>
        /// </summary>
        /// <param name="value">The <see cref="DateTime">value</see> to test.</param>
        /// <returns>Returns true if the value is valid and can be represented; false if not.</returns>
        /// <remarks>The standard Unix time is a signed integer data type, directly encoding the Unix time number,
        /// which is the number of seconds since 1970-01-01.
        /// Being 32 bits means the values here cover a range of about 136 years.
        /// The minimum representable time is 1901-12-13 20:45:52,
        /// and the maximum representable time is 2038-01-19 03:14:07.
        /// </remarks>
        public static bool IsValidValue(DateTime value)
        {
            return ((value >= new DateTime(1901, 12, 13, 20, 45, 52)) ||
                    (value <= new DateTime(2038, 1, 19, 03, 14, 07)));
        }

        /// <summary>
        /// Get /set the Modification Time
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        /// <seealso cref="IsValidValue"></seealso>
        public DateTime ModificationTime
        {
            get { return _modificationTime; }
            set
            {
                if (!IsValidValue(value))
                {
                    throw new ArgumentOutOfRangeException("value");
                }

                _flags |= Flags.ModificationTime;
                _modificationTime = value;
            }
        }

        /// <summary>
        /// Get / set the Access Time
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        /// <seealso cref="IsValidValue"></seealso>
        public DateTime AccessTime
        {
            get { return _lastAccessTime; }
            set
            {
                if (!IsValidValue(value))
                {
                    throw new ArgumentOutOfRangeException("value");
                }

                _flags |= Flags.AccessTime;
                _lastAccessTime = value;
            }
        }

        /// <summary>
        /// Get / Set the Create Time
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        /// <seealso cref="IsValidValue"></seealso>
        public DateTime CreateTime
        {
            get { return _createTime; }
            set
            {
                if (!IsValidValue(value))
                {
                    throw new ArgumentOutOfRangeException("value");
                }

                _flags |= Flags.CreateTime;
                _createTime = value;
            }
        }

        /// <summary>
        /// Get/set the <see cref="Flags">values</see> to include.
        /// </summary>
        Flags Include
        {
            get { return _flags; }
            set { _flags = value; }
        }

        #region Instance Fields
        Flags _flags;
        DateTime _modificationTime = new DateTime(1970, 1, 1);
        DateTime _lastAccessTime = new DateTime(1970, 1, 1);
        DateTime _createTime = new DateTime(1970, 1, 1);
        #endregion
    }

    /// <summary>
    /// Class handling NT date time values.
    /// </summary>
    internal class NTTaggedData : ITaggedData
    {
        /// <summary>
        /// Get the ID for this tagged data value.
        /// </summary>
        public short TagID
        {
            get { return 10; }
        }

        /// <summary>
        /// Set the data from the raw values provided.
        /// </summary>
        /// <param name="data">The raw data to extract values from.</param>
        /// <param name="index">The index to start extracting values from.</param>
        /// <param name="count">The number of bytes available.</param>
        public void SetData(byte[] data, int index, int count)
        {
            using (MemoryStream ms = new MemoryStream(data, index, count, false))
            using (ZipHelperStream helperStream = new ZipHelperStream(ms))
            {
                helperStream.ReadLEInt(); // Reserved
                while (helperStream.Position < helperStream.Length)
                {
                    int ntfsTag = helperStream.ReadLEShort();
                    int ntfsLength = helperStream.ReadLEShort();
                    if (ntfsTag == 1)
                    {
                        if (ntfsLength >= 24)
                        {
                            long lastModificationTicks = helperStream.ReadLELong();
                            _lastModificationTime = DateTime.FromFileTime(lastModificationTicks);

                            long lastAccessTicks = helperStream.ReadLELong();
                            _lastAccessTime = DateTime.FromFileTime(lastAccessTicks);

                            long createTimeTicks = helperStream.ReadLELong();
                            _createTime = DateTime.FromFileTime(createTimeTicks);
                        }
                        break;
                    }
                    else
                    {
                        // An unknown NTFS tag so simply skip it.
                        helperStream.Seek(ntfsLength, SeekOrigin.Current);
                    }
                }
            }
        }

        /// <summary>
        /// Get the binary data representing this instance.
        /// </summary>
        /// <returns>The raw binary data representing this instance.</returns>
        public byte[] GetData()
        {
            using (MemoryStream ms = new MemoryStream())
            using (ZipHelperStream helperStream = new ZipHelperStream(ms))
            {
                helperStream.IsStreamOwner = false;
                helperStream.WriteLEInt(0);       // Reserved
                helperStream.WriteLEShort(1);     // Tag
                helperStream.WriteLEShort(24);    // Length = 3 x 8.
                helperStream.WriteLELong(_lastModificationTime.ToFileTime());
                helperStream.WriteLELong(_lastAccessTime.ToFileTime());
                helperStream.WriteLELong(_createTime.ToFileTime());
                return ms.ToArray();
            }
        }

        /// <summary>
        /// Test a <see cref="DateTime"> valuie to see if is valid and can be represented here.</see>
        /// </summary>
        /// <param name="value">The <see cref="DateTime">value</see> to test.</param>
        /// <returns>Returns true if the value is valid and can be represented; false if not.</returns>
        /// <remarks>
        /// NTFS filetimes are 64-bit unsigned integers, stored in Intel
        /// (least significant byte first) byte order. They determine the
        /// number of 1.0E-07 seconds (1/10th microseconds!) past WinNT "epoch",
        /// which is "01-Jan-1601 00:00:00 UTC". 28 May 60056 is the upper limit
        /// </remarks>
        public static bool IsValidValue(DateTime value)
        {
            bool result = true;
            try
            {
                value.ToFileTimeUtc();
            }
            catch
            {
                result = false;
            }
            return result;
        }

        /// <summary>
        /// Get/set the <see cref="DateTime">last modification time</see>.
        /// </summary>
        public DateTime LastModificationTime
        {
            get { return _lastModificationTime; }
            set
            {
                if (!IsValidValue(value))
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                _lastModificationTime = value;
            }
        }

        /// <summary>
        /// Get /set the <see cref="DateTime">create time</see>
        /// </summary>
        public DateTime CreateTime
        {
            get { return _createTime; }
            set
            {
                if (!IsValidValue(value))
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                _createTime = value;
            }
        }

        /// <summary>
        /// Get /set the <see cref="DateTime">last access time</see>.
        /// </summary>
        public DateTime LastAccessTime
        {
            get { return _lastAccessTime; }
            set
            {
                if (!IsValidValue(value))
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                _lastAccessTime = value;
            }
        }

        #region Instance Fields
        DateTime _lastAccessTime = DateTime.FromFileTime(0);
        DateTime _lastModificationTime = DateTime.FromFileTime(0);
        DateTime _createTime = DateTime.FromFileTime(0);
        #endregion
    }

    /// <summary>
    /// A factory that creates <see cref="ITaggedData">tagged data</see> instances.
    /// </summary>
    interface ITaggedDataFactory
    {
        /// <summary>
        /// Get data for a specific tag value.
        /// </summary>
        /// <param name="tag">The tag ID to find.</param>
        /// <param name="data">The data to search.</param>
        /// <param name="offset">The offset to begin extracting data from.</param>
        /// <param name="count">The number of bytes to extract.</param>
        /// <returns>The located <see cref="ITaggedData">value found</see>, or null if not found.</returns>
        ITaggedData Create(short tag, byte[] data, int offset, int count);
    }

    /// 
    /// <summary>
    /// A class to handle the extra data field for Zip entries
    /// </summary>
    /// <remarks>
    /// Extra data contains 0 or more values each prefixed by a header tag and length.
    /// They contain zero or more bytes of actual data.
    /// The data is held internally using a copy on write strategy.  This is more efficient but
    /// means that for extra data created by passing in data can have the values modified by the caller
    /// in some circumstances.
    /// </remarks>
    sealed internal class ZipExtraData : IDisposable
    {
        #region Constructors
        /// <summary>
        /// Initialise a default instance.
        /// </summary>
        public ZipExtraData()
        {
            Clear();
        }

        /// <summary>
        /// Initialise with known extra data.
        /// </summary>
        /// <param name="data">The extra data.</param>
        public ZipExtraData(byte[] data)
        {
            if (data == null)
            {
                _data = new byte[0];
            }
            else
            {
                _data = data;
            }
        }
        #endregion

        /// <summary>
        /// Get the raw extra data value
        /// </summary>
        /// <returns>Returns the raw byte[] extra data this instance represents.</returns>
        public byte[] GetEntryData()
        {
            if (Length > ushort.MaxValue)
            {
                throw new ZipException("Data exceeds maximum length");
            }

            return (byte[])_data.Clone();
        }

        /// <summary>
        /// Clear the stored data.
        /// </summary>
        public void Clear()
        {
            if ((_data == null) || (_data.Length != 0))
            {
                _data = new byte[0];
            }
        }

        /// <summary>
        /// Gets the current extra data length.
        /// </summary>
        public int Length
        {
            get { return _data.Length; }
        }

        /// <summary>
        /// Get a read-only <see cref="Stream"/> for the associated tag.
        /// </summary>
        /// <param name="tag">The tag to locate data for.</param>
        /// <returns>Returns a <see cref="Stream"/> containing tag data or null if no tag was found.</returns>
        public Stream GetStreamForTag(int tag)
        {
            Stream result = null;
            if (Find(tag))
            {
                result = new MemoryStream(_data, _index, _readValueLength, false);
            }
            return result;
        }

        /// <summary>
        /// Get the <see cref="ITaggedData">tagged data</see> for a tag.
        /// </summary>
        /// <param name="tag">The tag to search for.</param>
        /// <returns>Returns a <see cref="ITaggedData">tagged value</see> or null if none found.</returns>
        private ITaggedData GetData(short tag)
        {
            ITaggedData result = null;
            if (Find(tag))
            {
                result = Create(tag, _data, _readValueStart, _readValueLength);
            }
            return result;
        }

        static ITaggedData Create(short tag, byte[] data, int offset, int count)
        {
            ITaggedData result = null;
            switch (tag)
            {
                case 0x000A:
                    result = new NTTaggedData();
                    break;
                case 0x5455:
                    result = new ExtendedUnixData();
                    break;
                default:
                    result = new RawTaggedData(tag);
                    break;
            }
            result.SetData(data, offset, count);
            return result;
        }

        /// <summary>
        /// Get the length of the last value found by <see cref="Find"/>
        /// </summary>
        /// <remarks>This is only valid if <see cref="Find"/> has previously returned true.</remarks>
        public int ValueLength
        {
            get { return _readValueLength; }
        }

        /// <summary>
        /// Get the index for the current read value.
        /// </summary>
        /// <remarks>This is only valid if <see cref="Find"/> has previously returned true.
        /// Initially the result will be the index of the first byte of actual data.  The value is updated after calls to
        /// <see cref="ReadInt"/>, <see cref="ReadShort"/> and <see cref="ReadLong"/>. </remarks>
        public int CurrentReadIndex
        {
            get { return _index; }
        }

        /// <summary>
        /// Get the number of bytes remaining to be read for the current value;
        /// </summary>
        public int UnreadCount
        {
            get
            {
                if ((_readValueStart > _data.Length) ||
                    (_readValueStart < 4))
                {
                    throw new ZipException("Find must be called before calling a Read method");
                }

                return _readValueStart + _readValueLength - _index;
            }
        }

        /// <summary>
        /// Find an extra data value
        /// </summary>
        /// <param name="headerID">The identifier for the value to find.</param>
        /// <returns>Returns true if the value was found; false otherwise.</returns>
        public bool Find(int headerID)
        {
            _readValueStart = _data.Length;
            _readValueLength = 0;
            _index = 0;

            int localLength = _readValueStart;
            int localTag = headerID - 1;

            // Trailing bytes that cant make up an entry (as there arent enough
            // bytes for a tag and length) are ignored!
            while ((localTag != headerID) && (_index < _data.Length - 3))
            {
                localTag = ReadShortInternal();
                localLength = ReadShortInternal();
                if (localTag != headerID)
                {
                    _index += localLength;
                }
            }

            bool result = (localTag == headerID) && ((_index + localLength) <= _data.Length);

            if (result)
            {
                _readValueStart = _index;
                _readValueLength = localLength;
            }

            return result;
        }

        /// <summary>
        /// Add a new entry to extra data.
        /// </summary>
        /// <param name="taggedData">The <see cref="ITaggedData"/> value to add.</param>
        public void AddEntry(ITaggedData taggedData)
        {
            if (taggedData == null)
            {
                throw new ArgumentNullException("taggedData");
            }
            AddEntry(taggedData.TagID, taggedData.GetData());
        }

        /// <summary>
        /// Add a new entry to extra data
        /// </summary>
        /// <param name="headerID">The ID for this entry.</param>
        /// <param name="fieldData">The data to add.</param>
        /// <remarks>If the ID already exists its contents are replaced.</remarks>
        public void AddEntry(int headerID, byte[] fieldData)
        {
            if ((headerID > ushort.MaxValue) || (headerID < 0))
            {
                throw new ArgumentOutOfRangeException("headerID");
            }

            int addLength = (fieldData == null) ? 0 : fieldData.Length;

            if (addLength > ushort.MaxValue)
            {
#if NETCF_1_0
				throw new ArgumentOutOfRangeException("fieldData");
#else
                throw new ArgumentOutOfRangeException("fieldData", "exceeds maximum length");
#endif
            }

            // Test for new length before adjusting data.
            int newLength = _data.Length + addLength + 4;

            if (Find(headerID))
            {
                newLength -= (ValueLength + 4);
            }

            if (newLength > ushort.MaxValue)
            {
                throw new ZipException("Data exceeds maximum length");
            }

            Delete(headerID);

            byte[] newData = new byte[newLength];
            _data.CopyTo(newData, 0);
            int index = _data.Length;
            _data = newData;
            SetShort(ref index, headerID);
            SetShort(ref index, addLength);
            if (fieldData != null)
            {
                fieldData.CopyTo(newData, index);
            }
        }

        /// <summary>
        /// Start adding a new entry.
        /// </summary>
        /// <remarks>Add data using <see cref="AddData(byte[])"/>, <see cref="AddLeShort"/>, <see cref="AddLeInt"/>, or <see cref="AddLeLong"/>.
        /// The new entry is completed and actually added by calling <see cref="AddNewEntry"/></remarks>
        /// <seealso cref="AddEntry(ITaggedData)"/>
        public void StartNewEntry()
        {
            _newEntry = new MemoryStream();
        }

        /// <summary>
        /// Add entry data added since <see cref="StartNewEntry"/> using the ID passed.
        /// </summary>
        /// <param name="headerID">The identifier to use for this entry.</param>
        public void AddNewEntry(int headerID)
        {
            byte[] newData = _newEntry.ToArray();
            _newEntry = null;
            AddEntry(headerID, newData);
        }

        /// <summary>
        /// Add a byte of data to the pending new entry.
        /// </summary>
        /// <param name="data">The byte to add.</param>
        /// <seealso cref="StartNewEntry"/>
        public void AddData(byte data)
        {
            _newEntry.WriteByte(data);
        }

        /// <summary>
        /// Add data to a pending new entry.
        /// </summary>
        /// <param name="data">The data to add.</param>
        /// <seealso cref="StartNewEntry"/>
        public void AddData(byte[] data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }

            _newEntry.Write(data, 0, data.Length);
        }

        /// <summary>
        /// Add a short value in little endian order to the pending new entry.
        /// </summary>
        /// <param name="toAdd">The data to add.</param>
        /// <seealso cref="StartNewEntry"/>
        public void AddLeShort(int toAdd)
        {
            unchecked
            {
                _newEntry.WriteByte((byte)toAdd);
                _newEntry.WriteByte((byte)(toAdd >> 8));
            }
        }

        /// <summary>
        /// Add an integer value in little endian order to the pending new entry.
        /// </summary>
        /// <param name="toAdd">The data to add.</param>
        /// <seealso cref="StartNewEntry"/>
        public void AddLeInt(int toAdd)
        {
            unchecked
            {
                AddLeShort((short)toAdd);
                AddLeShort((short)(toAdd >> 16));
            }
        }

        /// <summary>
        /// Add a long value in little endian order to the pending new entry.
        /// </summary>
        /// <param name="toAdd">The data to add.</param>
        /// <seealso cref="StartNewEntry"/>
        public void AddLeLong(long toAdd)
        {
            unchecked
            {
                AddLeInt((int)(toAdd & 0xffffffff));
                AddLeInt((int)(toAdd >> 32));
            }
        }

        /// <summary>
        /// Delete an extra data field.
        /// </summary>
        /// <param name="headerID">The identifier of the field to delete.</param>
        /// <returns>Returns true if the field was found and deleted.</returns>
        public bool Delete(int headerID)
        {
            bool result = false;

            if (Find(headerID))
            {
                result = true;
                int trueStart = _readValueStart - 4;

                byte[] newData = new byte[_data.Length - (ValueLength + 4)];
                Array.Copy(_data, 0, newData, 0, trueStart);

                int trueEnd = trueStart + ValueLength + 4;
                Array.Copy(_data, trueEnd, newData, trueStart, _data.Length - trueEnd);
                _data = newData;
            }
            return result;
        }

        #region Reading Support
        /// <summary>
        /// Read a long in little endian form from the last <see cref="Find">found</see> data value
        /// </summary>
        /// <returns>Returns the long value read.</returns>
        public long ReadLong()
        {
            ReadCheck(8);
            return (ReadInt() & 0xffffffff) | (((long)ReadInt()) << 32);
        }

        /// <summary>
        /// Read an integer in little endian form from the last <see cref="Find">found</see> data value.
        /// </summary>
        /// <returns>Returns the integer read.</returns>
        public int ReadInt()
        {
            ReadCheck(4);

            int result = _data[_index] + (_data[_index + 1] << 8) +
                (_data[_index + 2] << 16) + (_data[_index + 3] << 24);
            _index += 4;
            return result;
        }

        /// <summary>
        /// Read a short value in little endian form from the last <see cref="Find">found</see> data value.
        /// </summary>
        /// <returns>Returns the short value read.</returns>
        public int ReadShort()
        {
            ReadCheck(2);
            int result = _data[_index] + (_data[_index + 1] << 8);
            _index += 2;
            return result;
        }

        /// <summary>
        /// Read a byte from an extra data
        /// </summary>
        /// <returns>The byte value read or -1 if the end of data has been reached.</returns>
        public int ReadByte()
        {
            int result = -1;
            if ((_index < _data.Length) && (_readValueStart + _readValueLength > _index))
            {
                result = _data[_index];
                _index += 1;
            }
            return result;
        }

        /// <summary>
        /// Skip data during reading.
        /// </summary>
        /// <param name="amount">The number of bytes to skip.</param>
        public void Skip(int amount)
        {
            ReadCheck(amount);
            _index += amount;
        }

        void ReadCheck(int length)
        {
            if ((_readValueStart > _data.Length) ||
                (_readValueStart < 4))
            {
                throw new ZipException("Find must be called before calling a Read method");
            }

            if (_index > _readValueStart + _readValueLength - length)
            {
                throw new ZipException("End of extra data");
            }

            if (_index + length < 4)
            {
                throw new ZipException("Cannot read before start of tag");
            }
        }

        /// <summary>
        /// Internal form of <see cref="ReadShort"/> that reads data at any location.
        /// </summary>
        /// <returns>Returns the short value read.</returns>
        int ReadShortInternal()
        {
            if (_index > _data.Length - 2)
            {
                throw new ZipException("End of extra data");
            }

            int result = _data[_index] + (_data[_index + 1] << 8);
            _index += 2;
            return result;
        }

        void SetShort(ref int index, int source)
        {
            _data[index] = (byte)source;
            _data[index + 1] = (byte)(source >> 8);
            index += 2;
        }

        #endregion

        #region IDisposable Members

        /// <summary>
        /// Dispose of this instance.
        /// </summary>
        public void Dispose()
        {
            if (_newEntry != null)
            {
                _newEntry.Close();
            }
        }

        #endregion

        #region Instance Fields
        int _index;
        int _readValueStart;
        int _readValueLength;

        MemoryStream _newEntry;
        byte[] _data;
        #endregion
    }
}