Exemple #1
0
        internal int deflateParams(ZStream strm, int _level, int _strategy)
        {
            int result = 0;

            if (_level == -1)
            {
                _level = 6;
            }
            if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > 2)
            {
                return(-2);
            }
            if (Deflate.config_table[this.level].func != Deflate.config_table[_level].func && strm.total_in != 0L)
            {
                result = strm.deflate(1);
            }
            if (this.level != _level)
            {
                this.level            = _level;
                this.max_lazy_match   = Deflate.config_table[this.level].max_lazy;
                this.good_match       = Deflate.config_table[this.level].good_length;
                this.nice_match       = Deflate.config_table[this.level].nice_length;
                this.max_chain_length = Deflate.config_table[this.level].max_chain;
            }
            this.strategy = _strategy;
            return(result);
        }
Exemple #2
0
        internal int deflateParams(ZStream strm, int _level, int _strategy)
        {
            int num1 = 0;

            if (_level == -1)
            {
                _level = 6;
            }
            if (((_level < 0) || (_level > 9)) || ((_strategy < 0) || (_strategy > 2)))
            {
                return(-2);
            }
            if ((Deflate.config_table[this.level].func != Deflate.config_table[_level].func) && (strm.total_in != 0))
            {
                num1 = strm.deflate(1);
            }
            if (this.level != _level)
            {
                this.level            = _level;
                this.max_lazy_match   = Deflate.config_table[this.level].max_lazy;
                this.good_match       = Deflate.config_table[this.level].good_length;
                this.nice_match       = Deflate.config_table[this.level].nice_length;
                this.max_chain_length = Deflate.config_table[this.level].max_chain;
            }
            this.strategy = _strategy;
            return(num1);
        }
Exemple #3
0
        public int read(byte[] b, int off, int len)
        {
            if (len == 0)
            {
                return(0);
            }
            int err;

            z.next_out       = b;
            z.next_out_index = off;
            z.avail_out      = len;
            do
            {
                if ((z.avail_in == 0) && (!nomoreinput))
                {
                    // if buffer is empty and more input is avaiable, refill it
                    z.next_in_index = 0;
                    z.avail_in      = SupportClass.ReadInput(in_Renamed, buf, 0, bufsize);                //(bufsize<z.avail_out ? bufsize : z.avail_out));
                    if (z.avail_in == -1)
                    {
                        z.avail_in  = 0;
                        nomoreinput = true;
                    }
                }
                if (compress)
                {
                    err = z.deflate(flush);
                }
                else
                {
                    err = z.inflate(flush);
                }
                if (nomoreinput && (err == zlibConst.Z_BUF_ERROR))
                {
                    return(-1);
                }
                if (err != zlibConst.Z_OK && err != zlibConst.Z_STREAM_END)
                {
                    throw new ZStreamException((compress?"de":"in") + "flating: " + z.msg);
                }
                if (nomoreinput && (z.avail_out == len))
                {
                    return(-1);
                }
            }while (z.avail_out == len && err == zlibConst.Z_OK);
            //System.err.print("("+(len-z.avail_out)+")");
            return(len - z.avail_out);
        }
		internal int deflateParams(ZStream strm, int _level, int _strategy)
		{
			int err = Z_OK;
			
			if (_level == Z_DEFAULT_COMPRESSION)
			{
				_level = 6;
			}
			if (_level < 0 || _level > 9 || _strategy < 0 || _strategy > Z_HUFFMAN_ONLY)
			{
				return Z_STREAM_ERROR;
			}
			
			if (config_table[level].func != config_table[_level].func && strm.total_in != 0)
			{
				// Flush the last buffer:
				err = strm.deflate(Z_PARTIAL_FLUSH);
			}
			
			if (level != _level)
			{
				level = _level;
				max_lazy_match = config_table[level].max_lazy;
				good_match = config_table[level].good_length;
				nice_match = config_table[level].nice_length;
				max_chain_length = config_table[level].max_chain;
			}
			strategy = _strategy;
			return err;
		}
Exemple #5
0
 internal int deflateParams(ZStream strm, int _level, int _strategy)
 {
     int num1 = 0;
     if (_level == -1)
     {
         _level = 6;
     }
     if (((_level < 0) || (_level > 9)) || ((_strategy < 0) || (_strategy > 2)))
     {
         return -2;
     }
     if ((Deflate.config_table[this.level].func != Deflate.config_table[_level].func) && (strm.total_in != 0))
     {
         num1 = strm.deflate(1);
     }
     if (this.level != _level)
     {
         this.level = _level;
         this.max_lazy_match = Deflate.config_table[this.level].max_lazy;
         this.good_match = Deflate.config_table[this.level].good_length;
         this.nice_match = Deflate.config_table[this.level].nice_length;
         this.max_chain_length = Deflate.config_table[this.level].max_chain;
     }
     this.strategy = _strategy;
     return num1;
 }
Exemple #6
0
 protected override int PerformZlibOperation(ZStream zs, int flush)
 {
     return zs.deflate(flush);
 }
Exemple #7
0
        public static PhpBytes GzEncode(PhpBytes data, int level, int encoding_mode)
        {
            if ((level < -1) || (level > 9))
            {
                PhpException.Throw(PhpError.Warning, String.Format("compression level ({0}) must be within -1..9", level));
                return null;
            }

            ZStream zs = new ZStream();
            int status = zlibConst.Z_OK;

            zs.next_in = data.ReadonlyData;
            zs.avail_in = data.Length;

            // heuristic for max data length
            zs.avail_out = data.Length + data.Length / Zlib.PHP_ZLIB_MODIFIER + 15 + 1;
            zs.next_out = new byte[zs.avail_out];

            switch (encoding_mode)
            {
                case (int)ForceConstants.FORCE_GZIP:
                    if ((status = zs.deflateInit(level, -MAX_WBITS)) != zlibConst.Z_OK) 
                    {
                        PhpException.Throw(PhpError.Warning, zError(status));
                        return null;
			        }
                    break;
                case (int)ForceConstants.FORCE_DEFLATE:
                    if ((status = zs.deflateInit(level)) != zlibConst.Z_OK)
                    {
                        PhpException.Throw(PhpError.Warning, zError(status));
                        return null;
                    }
                    break;
            }

            status = zs.deflate(zlibConst.Z_FINISH);

            if (status != zlibConst.Z_STREAM_END)
            {
                zs.deflateEnd();

                if (status == zlibConst.Z_OK)
                {
                    status = zlibConst.Z_STREAM_ERROR;
                }
            }
            else
            {
                status = zs.deflateEnd();
            }

			z_error = zs.msg;

            if (status == zlibConst.Z_OK)
            {
                long output_length = zs.total_out + (encoding_mode == (int)ForceConstants.FORCE_GZIP ? GZIP_HEADER_LENGTH + GZIP_FOOTER_LENGTH : GZIP_HEADER_LENGTH);
                long output_offset = GZIP_HEADER_LENGTH;

                byte[] output = new byte[output_length];
                Buffer.BlockCopy(zs.next_out, 0, output, (int)output_offset, (int)zs.total_out);

                // fill the header
                output[0] = GZIP_HEADER[0];
                output[1] = GZIP_HEADER[1];
                output[2] = Z_DEFLATED; // zlib constant (private in ZLIB.NET)
                output[3] = 0; // reserved flag bits (this function puts invalid flags in here)
                // 4-8 represent time and are set to zero
                output[9] = OS_CODE; // php constant

                if (encoding_mode == (int)ForceConstants.FORCE_GZIP)
                {
                    var crc_algo = new PHP.Library.CRC32();
                    byte[] crc = crc_algo.ComputeHash(data.ReadonlyData, 0, data.Length);
                    crc_algo.Dispose();

                    output[output_length - 8] = crc[0];
                    output[output_length - 7] = crc[1];
                    output[output_length - 6] = crc[2];
                    output[output_length - 5] = crc[3];
                    output[output_length - 4] = (byte)(zs.total_in & 0xFF);
                    output[output_length - 3] = (byte)((zs.total_in >> 8) & 0xFF);
                    output[output_length - 2] = (byte)((zs.total_in >> 16) & 0xFF);
                    output[output_length - 1] = (byte)((zs.total_in >> 24) & 0xFF);
                }

                return new PhpBytes(output);
            }
            else
            {
                PhpException.Throw(PhpError.Warning, zError(status));
                return null;
            }
        }
Exemple #8
0
        public static PhpBytes GzDeflate(PhpBytes data, int level)
        {
            if ((level < -1) || (level > 9))
            {
                PhpException.Throw(PhpError.Warning, String.Format("compression level ({0}) must be within -1..9", level));
                return null;
            }

            ZStream zs = new ZStream();

            zs.next_in = data.ReadonlyData;
            zs.avail_in = data.Length;

            // heuristic for max data length
            zs.avail_out = data.Length + data.Length / PHP_ZLIB_MODIFIER + 15 + 1;
            zs.next_out = new byte[zs.avail_out];

            // -15 omits the header (undocumented feature of zlib)
            int status = zs.deflateInit(level, -MAX_WBITS);

            if (status == zlibConst.Z_OK)
            {
                status = zs.deflate(zlibConst.Z_FINISH);
                if (status != zlibConst.Z_STREAM_END)
                {
                    zs.deflateEnd();
                    if (status == zlibConst.Z_OK)
                    {
                        status = zlibConst.Z_BUF_ERROR;
                    }
                }
                else
                {
                    status = zs.deflateEnd();
                }
            }

            if (status == zlibConst.Z_OK)
            {
                byte[] result = new byte[zs.total_out];
                Buffer.BlockCopy(zs.next_out, 0, result, 0, (int)zs.total_out);
                return new PhpBytes(result);
            }
            else
            {
                PhpException.Throw(PhpError.Warning, zError(status));
                return null;
            }
        }
Exemple #9
0
        /// <summary>
        /// Reimplements function from zlib (compress2) that is not present in ZLIB.NET.
        /// </summary>
        /// <param name="dest">Destination array of bytes. May be trimmed if necessary.</param>
        /// <param name="source">Source array of bytes.</param>
        /// <param name="level">Level of compression.</param>
        /// <returns>Zlib status code.</returns>
        private static int ZlibCompress(ref byte[] dest, byte[] source, int level)
        {
            ZStream stream = new ZStream();
            int err;

            stream.next_in = source;
            stream.avail_in = source.Length;
            stream.next_out = dest;
            stream.avail_out = dest.Length;

            err = stream.deflateInit(level);
            if (err != zlibConst.Z_OK) return err;

            err = stream.deflate(zlibConst.Z_FINISH);
            if (err != zlibConst.Z_STREAM_END)
            {
                stream.deflateEnd();
                return err == zlibConst.Z_OK ? zlibConst.Z_BUF_ERROR : err;
            }

            if (stream.total_out != dest.Length)
            {
                byte[] output = new byte[stream.total_out];
                Buffer.BlockCopy(stream.next_out, 0, output, 0, (int)stream.total_out);
                dest = output;
            }

            return stream.deflateEnd();
        }