CXLIII. Zlib Compression Functions

Introduction

This module enables you to transparently read and write gzip (.gz) compressed files, through versions of most of the filesystem functions which work with gzip-compressed files (and uncompressed files, too, but not with sockets).

Note: Version 4.0.4 introduced a fopen-wrapper for .gz-files, so that you can use a special 'zlib:' URL to access compressed files transparently using the normal f*() file access functions if you prepend the filename or path with a 'zlib:' prefix when calling fopen().
In version 4.3.0, this special prefix has been changed to 'zlib://' to prevent ambiguities with filenames containing ':'.
This feature requires a C runtime library that provides the fopencookie() function. To my current knowledge the GNU libc is the only library that provides this feature.

Requirements

This module uses the functions of zlib by Jean-loup Gailly and Mark Adler. You have to use a zlib version >= 1.0.9 with this module.

Installation

Zlib support in PHP is not enabled by default. You will need to configure PHP --with-zlib[=DIR]

The windows version of PHP has built in support for this extension. You do not need to load any additional extension in order to use these functions.

Note: Builtin support for zlib on Windows is available with PHP 4.3.0.

Runtime Configuration

The behaviour of these functions is affected by settings in php.ini.

The zlib extension offers the option to transparently compress your pages on-the-fly, if the requesting browser supports this. Therefore there are three options in the configuration file php.ini.

Table 1. Zlib Configuration Options

Name	Default	Changeable	Changelog
zlib.output_compression	"0"	PHP_INI_ALL	Available since PHP 4.0.5.
zlib.output_compression_level	"-1"	PHP_INI_ALL	Available since PHP 4.3.0.
zlib.output_handler	""	PHP_INI_ALL	Available since PHP 4.3.0.

For further details and definitions of the PHP_INI_* constants, see the Appendix H.

Here's a short explanation of the configuration directives.

zlib.output_compression boolean/integer

Whether to transparently compress pages. If this option is set to "On" in php.ini or the Apache configuration, pages are compressed if the browser sends an "Accept-Encoding: gzip" or "deflate" header. "Content-Encoding: gzip" (respectively "deflate") and "Vary: Accept-Encoding" headers are added to the output.

This option also accepts integer values instead of boolean "On"/"Off", using this you can set the output buffer size (default is 4KB).

Note: output_handler must be empty if this is set 'On' ! Instead you must use zlib.output_handler.

zlib.output_compression_level integer

Compression level used for transparent output compression.

zlib.output_handler string

You cannot specify additional output handlers if zlib.output_compression is activated here. This setting does the same as output_handler but in a different order.

Resource Types

This extension has no resource types defined.

Predefined Constants

The constants below are defined by this extension, and will only be available when the extension has either been compiled into PHP or dynamically loaded at runtime.

FORCE_GZIP (integer)
FORCE_DEFLATE (integer)

Examples

This example opens a temporary file and writes a test string to it, then it prints out the content of this file twice.

Example 1. Small Zlib Example


<?php



$filename = tempnam('/tmp', 'zlibtest') . '.gz';

echo "<html>\n<head></head>\n<body>\n<pre>\n";

$s = "Only a test, test, test, test, test, test, test, test!\n";



// open file for writing with maximum compression

$zp = gzopen($filename, "w9");



// write string to file

gzwrite($zp, $s);



// close file

gzclose($zp);



// open file for reading

$zp = gzopen($filename, "r");



// read 3 char

echo gzread($zp, 3);



// output until end of the file and close it.

gzpassthru($zp);

gzclose($zp);



echo "\n";



// open file and print content (the 2nd time).

if (readgzfile($filename) != strlen($s)) {

        echo "Error with zlib functions!";

}

unlink($filename);

echo "</pre>\n</body>\n</html>\n";



?>

Table of Contents
gzclose -- Close an open gz-file pointer
gzcompress -- Compress a string
gzdeflate -- Deflate a string
gzencode -- Create a gzip compressed string
gzeof -- Test for end-of-file on a gz-file pointer
gzfile -- Read entire gz-file into an array
gzgetc -- Get character from gz-file pointer
gzgets -- Get line from file pointer
gzgetss -- Get line from gz-file pointer and strip HTML tags
gzinflate -- Inflate a deflated string
gzopen -- Open gz-file
gzpassthru -- Output all remaining data on a gz-file pointer
gzputs -- Alias of gzwrite()
gzread -- Binary-safe gz-file read
gzrewind -- Rewind the position of a gz-file pointer
gzseek -- Seek on a gz-file pointer
gztell -- Tell gz-file pointer read/write position
gzuncompress -- Uncompress a compressed string
gzwrite -- Binary-safe gz-file write
readgzfile -- Output a gz-file
zlib_get_coding_type -- Returns the coding type used for output compression

User Contributed Notes
Zlib Compression Functions

admin_at_commandline_dot_ch
08-Oct-2004 07:32


My gzip function.



This function read, compress and writhe only small chunks at one time, this way you can compress big files without memory problems...



<?php

function gzip($src, $level = 5, $dst = false){

    if($dst == false){

        $dst = $src.".gz";

    }

    if(file_exists($src)){

        $filesize = filesize($src);

        $src_handle = fopen($src, "r");

        if(!file_exists($dst)){

            $dst_handle = gzopen($dst, "w$level");

            while(!feof($src_handle)){

                $chunk = fread($src_handle, 2048);

                gzwrite($dst_handle, $chunk);

            }

            fclose($src_handle);

            gzclose($dst_handle);

            return true;

        } else {

            error_log("$dst already exists");

        }

    } else {

        error_log("$src doesn't exist");

    }

    return false;

}

?>

gem at rellim dot com
13-Jul-2004 10:03


Run, do not walk, run, to add this to your Apache config file:



php_flag zlib.output_compression On

php_value zlib.output_compression_level 5



I just tried this and achieved 10x and 15x speed inprovement on

some mature php pages.  Pages I have been seating over to make 5% gains on.  I use microtime() on critical pages to help me track page speed and that confirms the speed improvement.  The php page takes a timestamp at the beginning and end, then logs the page duration.  So any IP transmission effects are not included.  There is

a clear subjective difference to the user.



The test system was PHP 4.3.6, Apache 2.0.49 over Linux 2.4.

As always YMMV.

zigazou at free dot fr
12-Jun-2004 05:44


If you use "zlib.output_compression = On" in your php.ini file, and activates output buffering (ob_start), don't output this header :

header('Content-Length: '.ob_get_length());



This is because ob_get_length() will return the uncompressed size while zlib will compress the output. Thus your browser will get confused waiting for extra data that will never come.

xorinox at tiscali dot ch
04-Jun-2004 09:52


Have a look to this extended version :)



<?php



function compress( $srcFileName, $dstFileName )

{

    // getting file content

    $fp = fopen( $srcFileName, "r" );

    $data = fread ( $fp, filesize( $srcFileName ) );

    fclose( $fp );

    

    // writing compressed file

    $zp = gzopen( $dstFileName, "w9" );

    gzwrite( $zp, $data );

    gzclose( $zp );

}



function uncompress( $srcFileName, $dstFileName, $fileSize )

{

    // getting content of the compressed file

    $zp = gzopen( $srcFileName, "r" );

    $data = fread ( $zp, $fileSize );

    gzclose( $zp );

    

    // writing uncompressed file

    $fp = fopen( $dstFileName, "w" );

    fwrite( $fp, $data );

    fclose( $fp );

}



compress( "tmp/supportkonzept.rtf", "tmp/_supportkonzept.rtf.gz" );

uncompress( "tmp/_supportkonzept.rtf.gz", "tmp/_supportkonzept.rtf", filesize( "tmp/supportkonzept.rtf" ) );



?>

ec10 at gmx dot net
20-May-2004 01:38


/**

 * @return bool

 * @param string $in

 * @param string $out

 * @param string $param = "1"

 * @desc compressing the file with the zlib-extension

*/

function gzip ($in, $out, $param="1")

{

    if (!file_exists ($in) || !is_readable ($in))

        return false;

    if ((!file_exists ($out) && !is_writable (dirname ($out)) || (file_exists($out) && !is_writable($out)) ))

        return false;

    

    $in_file = fopen ($in, "rb");

    if (!$out_file = gzopen ($out, "wb".$param)) {

        return false;

    }

    

    while (!feof ($in_file)) {

        $buffer = fgets ($in_file, 4096);

        gzwrite ($out_file, $buffer, 4096);

    }



    fclose ($in_file);

    gzclose ($out_file);

    

    return true;

}



/**

 * @return bool

 * @param string $in

 * @param string $out

 * @desc uncompressing the file with the zlib-extension

*/

function gunzip ($in, $out)

{

    if (!file_exists ($in) || !is_readable ($in))

        return false;

    if ((!file_exists ($out) && !is_writable (dirname ($out)) || (file_exists($out) && !is_writable($out)) ))

        return false;



    $in_file = gzopen ($in, "rb");

    $out_file = fopen ($out, "wb");



    while (!gzeof ($in_file)) {

        $buffer = gzread ($in_file, 4096);

        fwrite ($out_file, $buffer, 4096);

    }

 

    gzclose ($in_file);

    fclose ($out_file);

    

    return true;

}

spam at wildpeaks dot com
13-May-2004 09:04


For decompressing, i modified a function posted earlier (that way $string doesn't have a big size that may be beyond the memory limit if the gzipped file is big) :



function file_ungzip($fromFile, $toFile) {

    $zp = @gzopen($fromFile, "r");

    $fp = @fopen($toFile, "w");

    while(!@gzeof($zp)) {$string = @gzread($zp, 4096); @fwrite($fp, $string, strlen($string));}

    @gzclose($zp);

    @fclose($fp);

}

thivierr at telus dot net
17-Nov-2003 06:02


I found the absolute easiest way to read a gzip file is as follows:



echo file_get_contents("compress.zlib:///myphp/test.txt.gz");



To create a gzip file:

file_put_contents("compress.zlib:///myphp/test.txt.gz","Put this in the file\r\n");



Things to note about this:

-The best prefix to use is "compress.zlib", not "zlib"

-If you wish to specify a path starting in the root path, you actually end up with three slashes.  The above path corresponds to "/myphp/test.txt" on unix, and "c:\myphp\test.txt" on Windows (if C: is the current drive).  I tested it just on Windows.

-Compression and decompression both use the same prefix of "compress.zlib://" (plus one more slash to get a root dir).

-I'm using 5.0, so I'm not 100% sure which behaviour started in which version.

chris at mad-teaparty dot com
27-May-2003 07:10


Nice function. I did it the other way round:



function uncompress($srcName, $dstName) {

   $zp = gzopen($srcName, "r");

   while(!gzeof($zp))

        $string .= gzread($zp, 4096);

   gzclose($zp);



   $fp = fopen($dstName, "w");

   fwrite($fp, $string, strlen($string));

   fclose($fp);

}



uncompress("./myfile.txt.gz", "./myfile.txt");



A shorter approach would be:



function uncompress($srcName, $dstName) {

  $string = implode("", gzfile($srcName));

  $fp = fopen($dstName, "w");

  fwrite($fp, $string, strlen($string));

  fclose($fp);

}

devcontact at tech-island dot com
24-Mar-2003 09:47


The method of first reading the source file and then passing its content to the gzip function instead of simply the source and destination filename was a bit confusing for me.



So I have written a simple funtion you can use to compress files in the gzip format (gzip is readable by winzip like .zip files)



function compress($srcName, $dstName)

{

  $fp = fopen($srcName, "r");

  $data = fread ($fp, filesize($srcName));

  fclose($fp);



  $zp = gzopen($dstName, "w9");

  gzwrite($zp, $data);

  gzclose($zp);

}



// Compress a file

compress("/web/myfile.dat", "/web/myfile.gz");

mlevy at rgj dot com
12-Feb-2003 04:06


If you turn zlib.output_compression_level on, be advised that you shouldn't try to flush() the output in your scripts. PHP will add the gzip header but send the output uncompressed, which plays havoc with Mozilla. IE seems to handle it, though.

monte at ispi dot net
18-Apr-2001 08:02


An alternate way to handle gzip compression is to let the mod_gzip module of apache handle it. This seems to contradict the tutorial on phpbuilder.com saying that it won't compress php (or any dynamic) output, but mod_gzip as of version 1.3.17.1a works well for me.





Here is an example of an httpd.conf setup:





<IfModule mod_gzip.c>


mod_gzip_on                 Yes


mod_gzip_dechunk            Yes


mod_gzip_minimum_file_size  300


mod_gzip_maximum_file_size  0


mod_gzip_maximum_inmem_size 100000


mod_gzip_keep_workfiles     No


mod_gzip_temp_dir           /tmp


mod_gzip_item_include       file \.html$


mod_gzip_item_include       file \.jsp$


mod_gzip_item_include       file \.php$


mod_gzip_item_include       file \.pl$


mod_gzip_item_include       mime ^text/.*


mod_gzip_item_include       mime ^application/x-httpd-php


mod_gzip_item_include       mime ^httpd/unix-directory$


mod_gzip_item_include       handler ^perl-script$


mod_gzip_item_include       handler ^server-status$


mod_gzip_item_include       handler ^server-info$


mod_gzip_item_exclude       mime ^image/.*


</IfModule>





This will automatically compress all output of your files with the .php extention or the x-httpd-php mime type. Be sure to have dechunk set to Yes.