Synnefo » Pithos MS Client

// GzipInputStream.cs

//

// Copyright (C) 2001 Mike Krueger

//

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

using ICSharpCode.SharpZipLib.GZip;

using ICSharpCode.SharpZipLib.Silverlight.Checksums;

using ICSharpCode.SharpZipLib.Silverlight.Zip.Compression;

using ICSharpCode.SharpZipLib.Silverlight.Zip.Compression.Streams;

namespace ICSharpCode.SharpZipLib.Silverlight.GZip

{

    /// <summary>

    /// This filter stream is used to decompress a "GZIP" format stream.

    /// The "GZIP" format is described baseInputStream RFC 1952.

    /// 

    /// author of the original java version : John Leuner

    /// </summary>

    /// <example> This sample shows how to unzip a gzipped file

    /// <code>

    /// using System;

    /// using System.IO;

    /// 

    /// using ICSharpCode.SharpZipLib.Core;

    /// using ICSharpCode.SharpZipLib.GZip;

    /// 

    /// class MainClass

    /// {

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

    /// 	{

    ///			using (Stream inStream = new GZipInputStream(File.OpenRead(args[0])))

    ///			using (FileStream outStream = File.Create(Path.GetFileNameWithoutExtension(args[0]))) {

    ///				byte[] buffer = new byte[4096];

    ///				StreamUtils.Copy(inStream, outStream, buffer);

    /// 		}

    /// 	}

    /// }	

    /// </code>

    /// </example>

    public class GZipInputStream : InflaterInputStream

    {

        #region Instance Fields

        /// <summary>

        /// CRC-32 value for uncompressed data

        /// </summary>

        protected Crc32 crc = new Crc32();

        /// <summary>

        /// Indicates end of stream

        /// </summary>

        protected bool eos;

        // Have we read the GZIP header yet?

        private bool readGZIPHeader;

        #endregion

        #region Constructors

        /// <summary>

        /// Creates a GZipInputStream with the default buffer size

        /// </summary>

        /// <param name="baseInputStream">

        /// The stream to read compressed data from (baseInputStream GZIP format)

        /// </param>

        public GZipInputStream(Stream baseInputStream)

            : this(baseInputStream, 4096)

        {

        }

        /// <summary>

        /// Creates a GZIPInputStream with the specified buffer size

        /// </summary>

        /// <param name="baseInputStream">

        /// The stream to read compressed data from (baseInputStream GZIP format)

        /// </param>

        /// <param name="size">

        /// Size of the buffer to use

        /// </param>

        public GZipInputStream(Stream baseInputStream, int size)

            : base(baseInputStream, new Inflater(true), size)

        {

        }

        #endregion

        #region Stream overrides

        /// <summary>

        /// Reads uncompressed data into an array of bytes

        /// </summary>

        /// <param name="buffer">

        /// The buffer to read uncompressed data into

        /// </param>

        /// <param name="offset">

        /// The offset indicating where the data should be placed

        /// </param>

        /// <param name="count">

        /// The number of uncompressed bytes to be read

        /// </param>

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

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

        {

            // We first have to read the GZIP header, then we feed all the

            // rest of the data to the base class.

            //

            // As we do that we continually update the CRC32. Once the data is

            // finished, we check the CRC32

            //

            // This means we don't need our own buffer, as everything is done

            // in baseInputStream the superclass.

            if (!readGZIPHeader)

            {

                ReadHeader();

            }

            if (eos)

            {

                return 0;

            }

            // We don't have to read the header, so we just grab data from the superclass

            var bytesRead = base.Read(buffer, offset, count);

            if (bytesRead > 0)

            {

                crc.Update(buffer, offset, bytesRead);

            }

            if (inf.IsFinished)

            {

                ReadFooter();

            }

            return bytesRead;

        }

        #endregion

        #region Support routines

        private void ReadHeader()

        {

            // 1. Check the two magic bytes

            var headCRC = new Crc32();

            var magic = baseInputStream.ReadByte();

            if (magic < 0)

            {

                throw new EndOfStreamException("EOS reading GZIP header");

            }

            headCRC.Update(magic);

            if (magic != (GZipConstants.GZIP_MAGIC >> 8))

            {

                throw new GZipException("Error GZIP header, first magic byte doesn't match");

            }

            magic = baseInputStream.ReadByte();

            if (magic < 0)

            {

                throw new EndOfStreamException("EOS reading GZIP header");

            }

            if (magic != (GZipConstants.GZIP_MAGIC & 0xFF))

            {

                throw new GZipException("Error GZIP header,  second magic byte doesn't match");

            }

            headCRC.Update(magic);

            // 2. Check the compression type (must be 8)

            var compressionType = baseInputStream.ReadByte();

            if (compressionType < 0)

            {

                throw new EndOfStreamException("EOS reading GZIP header");

            }

            if (compressionType != 8)

            {

                throw new GZipException("Error GZIP header, data not in deflate format");

            }

            headCRC.Update(compressionType);

            // 3. Check the flags

            var flags = baseInputStream.ReadByte();

            if (flags < 0)

            {

                throw new EndOfStreamException("EOS reading GZIP header");

            }

            headCRC.Update(flags);

            /*    This flag byte is divided into individual bits as follows:

				bit 0   FTEXT

				bit 1   FHCRC

				bit 2   FEXTRA

				bit 3   FNAME

				bit 4   FCOMMENT

				bit 5   reserved

				bit 6   reserved

				bit 7   reserved

			*/

            // 3.1 Check the reserved bits are zero

            if ((flags & 0xd0) != 0)

            {

                throw new GZipException("Reserved flag bits in GZIP header != 0");

            }

            // 4.-6. Skip the modification time, extra flags, and OS type

            for (var i = 0; i < 6; i++)

            {

                var readByte = baseInputStream.ReadByte();

                if (readByte < 0)

                {

                    throw new EndOfStreamException("EOS reading GZIP header");

                }

                headCRC.Update(readByte);

            }

            // 7. Read extra field

            if ((flags & GZipConstants.FEXTRA) != 0)

            {

                // Skip subfield id

                for (var i = 0; i < 2; i++)

                {

                    var readByte = baseInputStream.ReadByte();

                    if (readByte < 0)

                    {

                        throw new EndOfStreamException("EOS reading GZIP header");

                    }

                    headCRC.Update(readByte);

                }

                if (baseInputStream.ReadByte() < 0 || baseInputStream.ReadByte() < 0)

                {

                    throw new EndOfStreamException("EOS reading GZIP header");

                }

                var len1 = baseInputStream.ReadByte();

                var len2 = baseInputStream.ReadByte();

                if ((len1 < 0) || (len2 < 0))

                {

                    throw new EndOfStreamException("EOS reading GZIP header");

                }

                headCRC.Update(len1);

                headCRC.Update(len2);

                var extraLen = (len1 << 8) | len2;

                for (var i = 0; i < extraLen; i++)

                {

                    var readByte = baseInputStream.ReadByte();

                    if (readByte < 0)

                    {

                        throw new EndOfStreamException("EOS reading GZIP header");

                    }

                    headCRC.Update(readByte);

                }

            }

            // 8. Read file name

            if ((flags & GZipConstants.FNAME) != 0)

            {

                int readByte;

                while ((readByte = baseInputStream.ReadByte()) > 0)

                {

                    headCRC.Update(readByte);

                }

                if (readByte < 0)

                {

                    throw new EndOfStreamException("EOS reading GZIP header");

                }

                headCRC.Update(readByte);

            }

            // 9. Read comment

            if ((flags & GZipConstants.FCOMMENT) != 0)

            {

                int readByte;

                while ((readByte = baseInputStream.ReadByte()) > 0)

                {

                    headCRC.Update(readByte);

                }

                if (readByte < 0)

                {

                    throw new EndOfStreamException("EOS reading GZIP header");

                }

                headCRC.Update(readByte);

            }

            // 10. Read header CRC

            if ((flags & GZipConstants.FHCRC) != 0)

            {

                var crcval = baseInputStream.ReadByte();

                if (crcval < 0)

                {

                    throw new EndOfStreamException("EOS reading GZIP header");

                }

                int tempByte = baseInputStream.ReadByte();

                if (tempByte < 0)

                {

                    throw new EndOfStreamException("EOS reading GZIP header");

                }

                crcval = (crcval << 8) | tempByte;

                if (crcval != ((int) headCRC.Value & 0xffff))

                {

                    throw new GZipException("Header CRC value mismatch");

                }

            }

            readGZIPHeader = true;

        }

        private void ReadFooter()

        {

            var footer = new byte[8];

            var avail = inf.RemainingInput;

            if (avail > 8)

            {

                avail = 8;

            }

            Array.Copy(inputBuffer.RawData, inputBuffer.RawLength - inf.RemainingInput, footer, 0, avail);

            var needed = 8 - avail;

            while (needed > 0)

            {

                var count = baseInputStream.Read(footer, 8 - needed, needed);

                if (count <= 0)

                {

                    throw new EndOfStreamException("EOS reading GZIP footer");

                }

                needed -= count; // Jewel Jan 16

            }

            var crcval = (footer[0] & 0xff) | ((footer[1] & 0xff) << 8) | ((footer[2] & 0xff) << 16) | (footer[3] << 24);

            if (crcval != (int) crc.Value)

            {

                throw new GZipException("GZIP crc sum mismatch, theirs \"" + crcval + "\" and ours \"" + (int) crc.Value);

            }

            // NOTE The total here is the original total modulo 2 ^ 32.

            var total =

                ((uint) footer[4] & 0xff) |

                (((uint) footer[5] & 0xff) << 8) |

                (((uint) footer[6] & 0xff) << 16) |

                ((uint) footer[7] << 24);

            if ((inf.TotalOut & 0xffffffff) != total)

            {

                throw new GZipException("Number of bytes mismatch in footer");

            }

            // Should we support multiple gzip members.

            // Difficult, since there may be some bytes still in baseInputStream dataBuffer

            eos = true;

        }

        #endregion

    }

}