Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Function Reference : Zip File Functions

Zip File Functions

Introduction

This extension enables you to transparently read or write ZIP compressed archives and the files inside them.

Requirements

PHP 4

The bundled PHP 4 version requires » ZZIPlib, by Guido Draheim, version 0.10.6 or later

PHP 5.2.0 or later

This extension uses the functions of » zlib by Jean-loup Gailly and Mark Adler.

Installation

PHP 4

Note:

Zip support before PHP 4.1.0 is experimental.

Warning:

Because the PHP 4 zip extension is unmaintained we recommend that the PECL extension is used rather than the bundled one.

Linux systems

In order to use these functions you must compile PHP with zip support by using the --with-zip[=DIR] configure option, where [DIR] is the prefix of the » ZZIPlib library install.

Windows

Windows users need to enable php_zip.dll inside of php.ini in order to use these functions.

PHP 5.2.0 and later

Linux systems

In order to use these functions you must compile PHP with zip support by using the --enable-zip configure option.

Windows

Windows users need to enable php_zip.dll inside of php.ini in order to use these functions.

Installation via PECL

Information for installing this PECL extension may be found in the manual chapter titled Installation of PECL extensions. Additional information such as new releases, downloads, source files, maintainer information, and a CHANGELOG, can be located here: » http://pecl.php.net/package/zip.

The DLL for this PECL extension may be downloaded from either the » PHP Downloads page or from » http://pecl4win.php.net/

In PHP 4 this DLL resides in the extensions/ directory within the PHP Windows binaries download.

Runtime Configuration

This extension has no configuration directives defined in php.ini.

Resource Types

There are two resource types used in the Zip module. The first one is the Zip directory for the Zip archive, the second Zip Entry for the archive entries.

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.

ZipArchive uses class constants. There is three types of constants, Flags (FL_) errors (ER_) or mode (no prefix).

ZIPARCHIVE::CREATE (integer)
Create the archive if it does not exist.
ZIPARCHIVE::OVERWRITE (integer)
Always start a new archive, this mode will overwrite the file if it already exists.
ZIPARCHIVE::EXCL (integer)
Error if archive already exists.
ZIPARCHIVE::CHECKCONS (integer)
Perform additional consistency checks on the archive, and error if they fail.
ZIPARCHIVE::FL_NOCASE (integer)
Ignore case on name lookup
ZIPARCHIVE::FL_NODIR (integer)
Ignore directory component
ZIPARCHIVE::FL_COMPRESSED (integer)
Read compressed data
ZIPARCHIVE::FL_UNCHANGED (integer)
Use original data, ignoring changes.
ZIPARCHIVE::CM_DEFAULT (integer)
better of deflate or store.
ZIPARCHIVE::CM_STORE (integer)
stored (uncompressed).
ZIPARCHIVE::CM_SHRINK (integer)
shrunk
ZIPARCHIVE::CM_REDUCE_1 (integer)
reduced with factor 1
ZIPARCHIVE::CM_REDUCE_2 (integer)
reduced with factor 2
ZIPARCHIVE::CM_REDUCE_3 (integer)
reduced with factor 3
ZIPARCHIVE::CM_REDUCE_4 (integer)
reduced with factor 4
ZIPARCHIVE::CM_IMPLODE (integer)
imploded
ZIPARCHIVE::CM_DEFLATE (integer)
deflated
ZIPARCHIVE::CM_DEFLATE64 (integer)
deflate64
ZIPARCHIVE::CM_PKWARE_IMPLODE (integer)
PKWARE imploding
ZIPARCHIVE::CM_BZIP2 (integer)
BZIP2 algorithm
ZIPARCHIVE::ER_OK (integer)
No error.
ZIPARCHIVE::ER_MULTIDISK (integer)
Multi-disk zip archives not supported.
ZIPARCHIVE::ER_RENAME (integer)
Renaming temporary file failed.
ZIPARCHIVE::ER_CLOSE (integer)
Closing zip archive failed
ZIPARCHIVE::ER_SEEK (integer)
Seek error
ZIPARCHIVE::ER_READ (integer)
Read error
ZIPARCHIVE::ER_WRITE (integer)
Write error
ZIPARCHIVE::ER_CRC (integer)
CRC error
ZIPARCHIVE::ER_ZIPCLOSED (integer)
Containing zip archive was closed
ZIPARCHIVE::ER_NOENT (integer)
No such file.
ZIPARCHIVE::ER_EXISTS (integer)
File already exists
ZIPARCHIVE::ER_OPEN (integer)
Can't open file
ZIPARCHIVE::ER_TMPOPEN (integer)
Failure to create temporary file.
ZIPARCHIVE::ER_ZLIB (integer)
Zlib error
ZIPARCHIVE::ER_MEMORY (integer)
Memory allocation failure
ZIPARCHIVE::ER_CHANGED (string)
Entry has been changed
ZIPARCHIVE::ER_COMPNOTSUPP (integer)
Compression method not supported.
ZIPARCHIVE::ER_EOF (integer)
Premature EOF
ZIPARCHIVE::ER_INVAL (integer)
Invalid argument
ZIPARCHIVE::ER_NOZIP (integer)
Not a zip archive
ZIPARCHIVE::ER_INTERNAL (integer)
Internal error
ZIPARCHIVE::ER_INCONS (integer)
Zip archive inconsistent
ZIPARCHIVE::ER_REMOVE (integer)
Can't remove file
ZIPARCHIVE::ER_DELETED (integer)
Entry has been deleted

Examples

Example 2688. Create a Zip archive

copy to clipboard
<?php

$zip = new ZipArchive();
$filename = "./test112.zip";

if ($zip->open($filename, ZIPARCHIVE::CREATE)!==TRUE) {
   exit("cannot open <$filename>\n");
}

$zip->addFromString("testfilephp.txt" . time(), "#1 This is a test string added as testfilephp.txt.\n");
$zip->addFromString("testfilephp2.txt" . time(), "#2 This is a test string added as testfilephp2.txt.\n");
$zip->addFile($thisdir . "/too.php","/testfromfile.php");
echo "numfiles: " . $zip->numFiles . "\n";
echo "status:" . $zip->status . "\n";
$zip->close();
?>


Example 2689. Dump the archive details and listing

copy to clipboard
<?php
$za = new ZipArchive();

$za->open('test_with_comment.zip');
print_r($za);
var_dump($za);
echo "numFiles: " . $za->numFiles . "\n";
echo "status: " . $za->status  . "\n";
echo "statusSys: " . $za->statusSys . "\n";
echo "filename: " . $za->filename . "\n";
echo "comment: " . $za->comment . "\n";

for ($i=0; $i<$za->numFiles;$i++) {
   echo "index: $i\n";
   print_r($za->statIndex($i));
}
echo "numFile:" . $za->numFiles . "\n";
?>


Example 2690. Zip stream wrapper, read an OpenOffice meta info

copy to clipboard
<?php
$reader = new XMLReader();

$reader->open('zip://' . dirname(__FILE__) . '/test.odt#meta.xml');
$odt_meta = array();
while ($reader->read()) {
   if ($reader->nodeType == XMLREADER::ELEMENT) {
       $elm = $reader->name;
   } else {
       if ($reader->nodeType == XMLREADER::END_ELEMENT && $reader->name == 'office:meta') {
           break;
       }
       if (!trim($reader->value)) {
           continue;
       }
       $odt_meta[$elm] = $reader->value;
   }
}
print_r($odt_meta);
?>


This example uses the old API (PHP 4), it opens a ZIP file archive, reads each file in the archive and prints out its contents. The test2.zip archive used in this example is one of the test archives in the ZZIPlib source distribution.

Example 2691. Zip Usage Example

copy to clipboard
<?php

$zip = zip_open("/tmp/test2.zip");

if ($zip) {
   while ($zip_entry = zip_read($zip)) {
       echo "Name:               " . zip_entry_name($zip_entry) . "\n";
       echo "Actual Filesize:    " . zip_entry_filesize($zip_entry) . "\n";
       echo "Compressed Size:    " . zip_entry_compressedsize($zip_entry) . "\n";
       echo "Compression Method: " . zip_entry_compressionmethod($zip_entry) . "\n";

       if (zip_entry_open($zip, $zip_entry, "r")) {
           echo "File Contents:\n";
           $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
           echo "$buf\n";

           zip_entry_close($zip_entry);
       }
       echo "\n";

   }

   zip_close($zip);

}
?>


Table of Contents

zip_close — Close a ZIP file archive
zip_entry_close — Close a directory entry
zip_entry_compressedsize — Retrieve the compressed size of a directory entry
zip_entry_compressionmethod — Retrieve the compression method of a directory entry
zip_entry_filesize — Retrieve the actual file size of a directory entry
zip_entry_name — Retrieve the name of a directory entry
zip_entry_open — Open a directory entry for reading
zip_entry_read — Read from an open directory entry
zip_open — Open a ZIP file archive
zip_read — Read next entry in a ZIP file archive
ZipArchive::addEmptyDir — Add a new directory
ZipArchive::addFile — Adds a file to a ZIP archive from the given path
ZipArchive::addFromString — Add a file to a ZIP archive using its contents
ZipArchive::close — Close the active archive (opened or newly created)
ZipArchive::deleteIndex — delete an entry in the archive using its index
ZipArchive::deleteName — delete an entry in the archive using its name
ZipArchive::extractTo — Extract the archive contents
ZipArchive::getArchiveComment — Returns the Zip archive comment
ZipArchive::getCommentIndex — Returns the comment of an entry using the entry index
ZipArchive::getCommentName — Returns the comment of an entry using the entry name
ZipArchive::getFromIndex — Returns the entry contents using its index.
ZipArchive::getFromName — Returns the entry contents using its name.
ZipArchive::getNameIndex — Returns the name of an entry using its index
ZipArchive::getStream — Get a file handler to the entry defined by its name (read only).
ZipArchive::locateName — Returns the index of the entry in the archive
ZipArchive::open — Open a ZIP file archive
ZipArchive::renameIndex — Renames an entry defined by its index
ZipArchive::renameName — Renames an entry defined by its name
ZipArchive::setArchiveComment — Set the comment of a ZIP archive
ZipArchive::setCommentIndex — Set the comment of an entry defined by its index
ZipArchive::setCommentName — Set the comment of an entry defined by its name
ZipArchive::statIndex — Get the details of an entry defined by its index.
ZipArchive::statName — Get the details of an entry defined by its name.
ZipArchive::unchangeAll — Undo all changes done in the archive.
ZipArchive::unchangeArchive — Revert all global changes done in the archive.
ZipArchive::unchangeIndex — Revert all changes done to an entry at the given index.
ZipArchive::unchangeName — Revert all changes done to an entry with the given name.

Code Examples / Notes » ref.zip

nahaylo vitalik
Zip Class from Devin Doucette at phpclasses.org
Allows the creation of tar, gzip, bzip2, and zip archives, and the extraction of tar, gzip, and bzip2.
Supports relative paths/no paths, comments, and recursing through subdirectories.
Can write file to disk, allow user to download directly, or return file contents in a string or an array.
Does not require any external programs to run.
Here is a link: http://www.phpclasses.org/browse/package/945.html

lennart poot
You can use PHPMyAdmin's zip.lib library. It's available in the package PHPMyAdmin ( http://www.phpmyadmin.net/  ).
The zip class is located in /libraries/zip.lib.php
Next example generates a file named 'subfolder_in_zip_archive/_settings.php' using information of variable $settings. All files in folder 'folder_holding_files_to_add_to_zip' ($ad_dir) will be added to the archive as well.
In this example the raw zip archive data is responded to the browser. Uncomment the lines after 'write the file to disk' if you would like the archive to be stored on disk.
The function $zipfile -> addFile requires two parameters.
- The first parameter holds raw data and needs to be escaped using php function ‘stripcslashes’
- The second parameter holds the filename in the archive. You can enter complete paths to create complex folder structures
A timestamp can be added using the third additional parameter.
Regars,
Lennart Poot
<?php
 require_once('zip.lib.php');
 $zipfilename = 'zip_archive_to_generate.zip';
 $zip_subfolder = 'subfolder_in_zip_archive';
 $settings = '
   <?php
     $setting1 = "'.$setting1.'";
     $setting2 = "'.$setting2.'";
   ?>
 ';
 $ad_dir = 'folder_holding_files_to_add_to_zip';
 // form is posted, handle it    
 $zipfile = new zipfile();
 // generate _settings into zip file
 $zipfile ->addFile( stripcslashes( $settings ), $zip_subfolder . '/_settings.php' );
 if ($handle = opendir($ad_dir)) {
    while (false !== ($file = readdir($handle))) {
       if (!is_dir($file) && $file != "." && $file != ".." ) {
         $f_tmp = @fopen( $ad_dir . '/' . $file, 'r');
         if($f_tmp){
           $dump_buffer=fread( $f_tmp, filesize($ad_dir . '/' . $file));
           $zipfile -> addFile($dump_buffer, $zip_subfolder . '/' . $file);
           fclose( $f_tmp );
         }
       }
    }  
 $dump_buffer = $zipfile -> file();
 // write the file to disk:
 /*
 $file_pointer = fopen('newzip.zip', 'w');
 if($file_pointer){
   fwrite( $file_pointer, $dump_buffer, strlen($dump_buffer) );
   fclose( $file_pointer );
 }
 */
 // response zip archive to browser:
 header('Pragma: public');
 header('Content-type: application/zip');
 header('Content-length: ' . strlen($dump_buffer));
 header('Content-Disposition: attachment; filename="'.$zipfilename.'"');
 exit;
?>

ottawasixtyseven
WOW ... after weeks and weeks of research I thought I'd make somebody elses life a little easier. If you're wondering how to make PHP 4.2.3 read windows zip files (winzip, pkzip, etc) do this:
NOTE: THIS IS FOR WINDOWS SERVERS NOT LINUX OR OTHER. You need zziplib for Linux. http://zziplib.sourceforge.net/
ON PHP WINDOWS SERVER
1) Grab the php_zip.dll from the extensions dir in php-4.3.0pre2-Win32.zip
2) Add a line extension=php_zip.dll to your php.ini
3) Restart your web server
php_zip.dll obviously works on PHP 4.3.0pre2 but you can't run Zend Optimizer on PHP 4.3 (yet). You can run Zend Optimizer on PHP 4.2.3 but it doesn't ship with php_zip.dll. The php_zip.dll that ships with PHP 4.3.0pre2 may even work with older version but I haven't tested that.
For documentation on how to use the zip functions (not the gzip functions that are documented on the php site) go here:
http://zziplib.sourceforge.net/zziplib.html
Newbie Von Greenhorn

nheimann
With this extension you can Add dirs with files with the ZipArchive Object
/**
* FlxZipArchive, Extends ZipArchiv.
* Add Dirs with Files and Subdirs.
*
* <code>
*  $archive = new FlxZipArchive;
*  // .....
*  $archive->addDir( 'test/blub', 'blub' );
* </code>
*/
class FlxZipArchive extends ZipArchive {
/**
* Add a Dir with Files and Subdirs to the archive
*
* @param string $location Real Location
* @param string $name Name in Archive
* @author Nicolas Heimann
* @access private
**/
public function addDir($location, $name) {
$this->addEmptyDir($name);
$this->addDirDo($location, $name);
// } // EO addDir;
/**
* Add Files & Dirs to archive.
*
* @param string $location Real Location
* @param string $name Name in Archive
* @author Nicolas Heimann
* @access private
**/
private function addDirDo($location, $name) {
$name .= '/';
$location .= '/';
// Read all Files in Dir
$dir = opendir ($location);
while ($file = readdir($dir))
{
if ($file == '.' || $file == '..') continue;
// Rekursiv, If dir: FlxZipArchive::addDir(), else ::File();
$do = (filetype() == 'dir') ? 'addDir' : 'addFile';
$this->$do($location . $file, $name . $file);
}
} // EO addDirDo();
}

chris
Watch out with archives that contain subfolders if you're using the zip functions to extract archives to actual files.  Let's say you're trying to extract foldername/filename.txt from the archive.  You can't fopen a directory that doesn't exist, so you'll have to check for the existance of directory foldername and create it if it isn't found, then fopen foldername/filename.txt and begin writing to that.

bholub
This will simply unpack (including directories) $zip to $dir -- in this example the zip is being uploaded.
<?php
$dir = 'C:\\reports-temp\\';
$zip = zip_open($_FILES['report_zip']['tmp_name']);
while($zip_entry = zip_read($zip)) {
$entry = zip_entry_open($zip,$zip_entry);
$filename = zip_entry_name($zip_entry);
$target_dir = $dir.substr($filename,0,strrpos($filename,'/'));
$filesize = zip_entry_filesize($zip_entry);
if (is_dir($target_dir) || mkdir($target_dir)) {
if ($filesize > 0) {
$contents = zip_entry_read($zip_entry, $filesize);
file_put_contents($dir.$filename,$contents);
}
}
}
?>

nielsvandenberge
This is the function I use to unzip a file.
It includes the following options:
* Unzip in any directory you like
* Unzip in the directory of the zip file
* Unzip in a directory with the zipfile's name in the directory of the zip file. (i.e.: C:\test.zip will be unzipped in  C:\test\)
* Overwrite existing files or not
* It creates non existing directories with the function Create_dirs($path)
You should use absolute paths with slashes (/) instead of backslashes (\).
I tested it with PHP 5.2.0 with php_zip.dll extension loaded
<?php
/**
* Unzip the source_file in the destination dir
*
* @param   string      The path to the ZIP-file.
* @param   string      The path where the zipfile should be unpacked, if false the directory of the zip-file is used
* @param   boolean     Indicates if the files will be unpacked in a directory with the name of the zip-file (true) or not (false) (only if the destination directory is set to false!)
* @param   boolean     Overwrite existing files (true) or not (false)
*  
* @return  boolean     Succesful or not
*/
function unzip($src_file, $dest_dir=false, $create_zip_name_dir=true, $overwrite=true)
{
 if ($zip = zip_open($src_file))
 {
   if ($zip)
   {
     $splitter = ($create_zip_name_dir === true) ? "." : "/";
     if ($dest_dir === false) $dest_dir = substr($src_file, 0, strrpos($src_file, $splitter))."/";
     
     // Create the directories to the destination dir if they don't already exist
     create_dirs($dest_dir);
     // For every file in the zip-packet
     while ($zip_entry = zip_read($zip))
     {
       // Now we're going to create the directories in the destination directories
       
       // If the file is not in the root dir
       $pos_last_slash = strrpos(zip_entry_name($zip_entry), "/");
       if ($pos_last_slash !== false)
       {
         // Create the directory where the zip-entry should be saved (with a "/" at the end)
         create_dirs($dest_dir.substr(zip_entry_name($zip_entry), 0, $pos_last_slash+1));
       }
       // Open the entry
       if (zip_entry_open($zip,$zip_entry,"r"))
       {
         
         // The name of the file to save on the disk
         $file_name = $dest_dir.zip_entry_name($zip_entry);
         
         // Check if the files should be overwritten or not
         if ($overwrite === true || $overwrite === false && !is_file($file_name))
         {
           // Get the content of the zip entry
           $fstream = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
           file_put_contents($file_name, $fstream );
           // Set the rights
           chmod($file_name, 0777);
           echo "save: ".$file_name."<br />";
         }
         
         // Close the entry
         zip_entry_close($zip_entry);
       }      
     }
     // Close the zip-file
     zip_close($zip);
   }
 }
 else
 {
   return false;
 }
 
 return true;
}
/**
* This function creates recursive directories if it doesn't already exist
*
* @param String  The path that should be created
*  
* @return  void
*/
function create_dirs($path)
{
 if (!is_dir($path))
 {
   $directory_path = "";
   $directories = explode("/",$path);
   array_pop($directories);
   
   foreach($directories as $directory)
   {
     $directory_path .= $directory."/";
     if (!is_dir($directory_path))
     {
       mkdir($directory_path);
       chmod($directory_path, 0777);
     }
   }
 }
}
// Extract C:/zipfiletest/zip-file.zip to C:/zipfiletest/zip-file/ and overwrites existing files
unzip("C:/zipfiletest/zip-file.zip", false, true, true);
// Extract C:/zipfiletest/zip-file.zip to C:/another_map/zipfiletest/ and doesn't overwrite existing files. NOTE: It doesn't create a map with the zip-file-name!
unzip("C:/zipfiletest/zip-file.zip", "C:/another_map/zipfiletest/", true, false);
?>

angelnsn1
this function extract all files and subdirectories, you can choose verbose mode for get paths of files extracted. the function return a msg what indicate the error, if msg is OK, all is done.
---
code:
function unzip($dir, $file, $verbose = 0) {
  $dir_path = "$dir$file";
  $zip_path = "$dir$file.zip";
 
  $ERROR_MSGS[0] = "OK";
  $ERROR_MSGS[1] = "Zip path $zip_path doesn't exists.";
  $ERROR_MSGS[2] = "Directory $dir_path for unzip the pack already exists, impossible continue.";
  $ERROR_MSGS[3] = "Error while opening the $zip_path file.";
 
  $ERROR = 0;
 
  if (file_exists($zip_path)) {
 
   if (!file_exists($dir_path)) {
   
      mkdir($dir_path);
   
        if (($link = zip_open($zip_path))) {
       
           while (($zip_entry = zip_read($link)) && (!$ERROR)) {
           
              if (zip_entry_open($link, $zip_entry, "r")) {
         
                 $data = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                 $dir_name = dirname(zip_entry_name($zip_entry));
                 $name = zip_entry_name($zip_entry);
                 
                 if ($name[strlen($name)-1] == '/') {
                   
                  $base = "$dir_path/";
                    foreach ( explode("/", $name) as $k) {
                   
                       $base .= "$k/";
                       
                       if (!file_exists($base))
                          mkdir($base);
                       
                    }
                       
                 }
                 else {
                 
                  $name = "$dir_path/$name";
                 
                  if ($verbose)
                      echo "extracting: $name
";
                   
                   $stream = fopen($name, "w");
                   fwrite($stream, $data);
                   
                 }  
               
                 zip_entry_close($zip_entry);
               
              }
              else
                 $ERROR = 4;
 
             }
             
             zip_close($link);  
       
          }
          else
             $ERROR = "3";
      }
      else
         $ERROR = 2;
   }
   else
      $ERROR = 1;
     
  return $ERROR_MSGS[$ERROR];

}
---
example:
$error = unzip("d:/www/dir/", "zipname", 1);
echo $error;
---
i hope this help you,
good bye.

phpcontrib a t esurfers d o t c o m
Sometimes you may not be able to install the necessary resources to run the ZIP lib. Maybe because you have no control of the server, or maybe because you cannot find the correct libraries for your php...
Anyway do not despair, there is another solution!
I was in this situation (my client could not install it on the server) so I developed a small libraryin pure PHP that is compatible with PHP's own lib but uses the commandline 'unzip' command directly form PHP. You can configure it to use any commandline unzipping tool (so it should work even with other compressed files, as long as there is a commandline tool). It should work on most platforms with an unzip command (Win32 included) although I have tested only under unix.
What it does exactly, is replacing all the functions of the Zip library with equivalent ones. So the example in this page will work (just rename every zip_... function m_zip_...):
<?php
$zip =m_zip_open("/tmp/test2.zip");
if ($zip) {
   while ($zip_entry = m_zip_read($zip)) {
       echo "Name:               " . m_zip_entry_name($zip_entry) . "\n";
       echo "Actual Filesize:    " . m_zip_entry_filesize($zip_entry) . "\n";
       echo "Compressed Size:    " . m_zip_entry_compressedsize($zip_entry) . "\n";
       echo "Compression Method: " . m_zip_entry_compressionmethod($zip_entry) . "\n";
       if (m_zip_entry_open($zip, $zip_entry, "r")) {
           echo "File Contents:\n";
           $buf = m_zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
           echo "$buf\n";
           m_zip_entry_close($zip_entry);
       }
       echo "\n";
   }
   m_zip_close($zip);
}
?>
The library will create a new folder and call unzip on the file when you call m_zip_open().
It will get rid of all the unzipped things when you call m_zip_close().
It will walk the directory structure of the ZIP file as you call m_zip_read($zip) getting into directories and then out again.
Then you will be able to read chunks of (or th whole) files with m_zip_entry_read()
: : :   INCOMPATIBILITIES  : : :
Once the zipfile is unzipped, I will have no way to know the size of the entries or the compression methods, so the functions m_zip_entry_compressedsize() and m_zip_entry_compressionmethod() just return a '?'.
Of course what zipfiles will be compatible and what not will dependo on the command line tool you choose to use.
: : :   CONFIGURATION  : : :
There are two things to setup:
A path to a directory where we can create subfolders and unzip things:
define('UNZIP_DIR','/data/fandango/html/update/unzipped/');
The command to invoke to unzip the files:
define('UNZIP_CMD','unzip -o @_SRC_@ -x -d @_DST_@');
DO NOT REMOVE THE @_SRC_@ and @ _DST_@ markers. This is where the library will put the source file name you pass and the destination subfolder (it will create a subfolder of UNZIP_DIR and pass that)
: : :   DOWNLOAD  : : :
You will find the library and a demo file (with the example on this page) at http://esurfers.com/m-zip/

24-sep-2006 03:46
Previous poster's code is not using escape_shell_arg(), so it can be a huge security hole if attacker could manipulate filename/dir. I suggest replacing str_replace() with sprintf() and escape_shell_arg().

01-jul-2004 01:40
PKZipfiles (or Winzip files) can be easily created by using my Ziplib class, can be found on http://sourceforge.net/projects/phpziplib . All it requires is PHP to be compiled with zlib, and support for classes(don't know when they've been added, but I think with PHP4 you're safe).

mishania
Notes from phpContrib [ a t ] eSurfers D o t COM are a ROCK!!!
1)  In order to make it work U'll probably need:
** Allow Apache service to interact with desktop, but in that case U will notice momentarely console window opens and closes.  That's may be annoying.  The elegant solution instead of allowing interaction is redirect the command to some temporary file, and get rid of it later on:
define('UNZIP_CMD','unzip -o @_SRC_@ -x -d  
@_DST_@ > tmpfile.txt');
2)  I would recommend to use 7-zip, it's free and completely relyable.  Also, it's comes with stand alone console executable which makes it quite convenient to place it in some exec library folder within your source, and refferering directly to it.
define("UNZIP_CMD","7za.exe x @_SRC_@ -o@_DST_@ > tmpfile.txt");

candido1212
New Unzip function, recursive extract
Require mkdirr() (recursive create dir)
$file = "2537c61ef7f47fc3ae919da08bcc1911.zip";
$dir = getcwd();
function Unzip($dir, $file, $destiny="")
{
$dir .= DIRECTORY_SEPARATOR;
$path_file = $dir . $file;
$zip = zip_open($path_file);
$_tmp = array();
$count=0;
if ($zip)
{
while ($zip_entry = zip_read($zip))
{
$_tmp[$count]["filename"] = zip_entry_name($zip_entry);
           $_tmp[$count]["stored_filename"] = zip_entry_name($zip_entry);
           $_tmp[$count]["size"] = zip_entry_filesize($zip_entry);
           $_tmp[$count]["compressed_size"] = zip_entry_compressedsize($zip_entry);
           $_tmp[$count]["mtime"] = "";
           $_tmp[$count]["comment"] = "";
           $_tmp[$count]["folder"] = dirname(zip_entry_name($zip_entry));
           $_tmp[$count]["index"] = $count;
           $_tmp[$count]["status"] = "ok";
$_tmp[$count]["method"] = zip_entry_compressionmethod($zip_entry);

if (zip_entry_open($zip, $zip_entry, "r"))
{
$buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
if($destiny)
{
$path_file = str_replace("/",DIRECTORY_SEPARATOR, $destiny . zip_entry_name($zip_entry));
}
else
{
$path_file = str_replace("/",DIRECTORY_SEPARATOR, $dir . zip_entry_name($zip_entry));
}
$new_dir = dirname($path_file);

// Create Recursive Directory
mkdirr($new_dir);

$fp = fopen($dir . zip_entry_name($zip_entry), "w");
fwrite($fp, $buf);
fclose($fp);
zip_entry_close($zip_entry);
}
echo "\n</pre>";
$count++;
}
zip_close($zip);
}
}
Unzip($dir,$file);

martinlarsen
Lennart Poot's example of using phpMyAdmin's zip library is missing the echo that will actually output the final zip file.
At the end (but before the exit which isn't needed anyway), add this line:
echo $dump_buffer;

travis
just a not of caution--using the dynamic zip class mentioned earlier seems to cause issues with high ascii characters (their values are not preserved correctly, and the file will not unzip)

krishnendu
If you want to unzip an password protected file with php..try the following command....it works in Unix/Apache environment...I haven't tested in any other environment...
system("`which unzip` -P Password $zipfile -d $des",$ret_val)
Where $zipfile is the path to the .zip to be unzipped and $des is path to the destination directory.....here both absolute and relative path to the script (which contains this system command) will work...
if everything runs well...file should be unzipped at the $des directory..and you will get 0 value for $ret_val , which means success(info-zip.org)
Regards
Krishnendu

nosp
If you just want to unzip everything of a zip file in a directory (and create unexisting directories), let's try this:
function unzip($file, $path) {
 $zip = zip_open($file);
 if ($zip) {
   while ($zip_entry = zip_read($zip)) {
     if (zip_entry_filesize($zip_entry) > 0) {
       // str_replace must be used under windows to convert "/" into "\"
       $complete_path = $path.str_replace('/','\\',dirname(zip_entry_name($zip_entry)));
       $complete_name = $path.str_replace ('/','\\',zip_entry_name($zip_entry));
       if(!file_exists($complete_path)) {
         $tmp = '';
         foreach(explode('\\',$complete_path) AS $k) {
           $tmp .= $k.'\\';
           if(!file_exists($tmp)) {
             mkdir($tmp, 0777);
           }
         }
       }
       if (zip_entry_open($zip, $zip_entry, "r")) {
         $fd = fopen($complete_name, 'w');
         fwrite($fd, zip_entry_read($zip_entry, zip_entry_filesize($zip_entry)));
         fclose($fd);
         zip_entry_close($zip_entry);
       }
     }
   }
   zip_close($zip);
 }
}
To use this function:
unzip('c:\\file.zip','c:\\temp\\'); // BE CAREFULL: second argument *MUST* finish by a "\" ! ("/" under *nix)
Patrick

tom
If you just want to unzip a zip folder an alternative to some of the lengthy functions below is:
<?
function unzip($zip_file, $src_dir, $extract_dir)
{
copy($src_dir . "/" . $zip_file, $extract_dir . "/" . $zip_file);
chdir($extract_dir);
shell_exec("unzip $zip_file");
}
?>
You don't need the ZIP extension for this.

php
If you don't have the --with-zip=DIR compile option and can't change it, but you do have --with-pear, then you can use the pear Archive_Zip class available at http://cvs.php.net/pear/Archive_Zip/
As of 2004-06-23, the class isn't packaged and auto-documented yet, but like all pear classes, the comments are extremely verbose and helpful, and you can download the php file as a standalone.  Just include the Zip.php in your project, and you can use the class.

vangoethem
If you are looking for a way to create ZIP files dynamically in PHP, you should look at the wonderful zipfile class.
It seems there is no official page for this class. You may get it by retrieving the zip.lib.php from the PhpMyAdmin 2.5.2:
http://www.phpmyadmin.net/

23-feb-2005 04:54
If (as me) all you wanted to do is store a big string (for example, a serialized array or the like) in a mysql BLOB field, remember that mysql has a COMPRESS() and UNCOMPRESS() pair of functions that do exactly that. Compression/decompression is therefore available also when accessing the DB from other languages like java, etc.

max
I've needed a simple php class to manipulate zip files without PCEL extension, after reading all comment and tested 2 nice classes, here's my conclusion:
"You can use PHPMyAdmin's zip.lib"
-- Lennart Poot -- 12-Jul-2006 07:33
true, getting it is a bit awkward but the class is straight foward and works. BUT it only create zip files, it wont extract them.
"Hey guys, maybe you should check this out:
http://www.phpconcept.net/pclzip/index.en.php "
-- master_auer at web dot de -- 16-Nov-2003 07:49
true, check it if you need more advanced feature, this class is awsome.

10-may-2006 03:23
I try to use the function unpackZip from schore at NOSPAM dot hotmail dot com.
it appears that the fclose instruction is missing. Without that instruction, i've got some trouble to unpack zip file with recursive folders.
Here is the new code with the missing instruction
<?php
function unpackZip($dir,$file) {
  if ($zip = zip_open($dir.$file.".zip")) {
    if ($zip) {
      mkdir($dir.$file);
      while ($zip_entry = zip_read($zip)) {
        if (zip_entry_open($zip,$zip_entry,"r")) {
          $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
          $dir_name = dirname(zip_entry_name($zip_entry));
          if ($dir_name != ".") {
            $dir_op = $dir.$file."/";
              foreach ( explode("/",$dir_name) as $k) {
                $dir_op = $dir_op . $k;
                if (is_file($dir_op)) unlink($dir_op);
                if (!is_dir($dir_op)) mkdir($dir_op);
                $dir_op = $dir_op . "/" ;
                }
              }
          $fp=fopen($dir.$file."/".zip_entry_name($zip_entry),"w");
          fwrite($fp,$buf);
          fclose($fp);
          zip_entry_close($zip_entry);
      } else
          return false;
      }
      zip_close($zip);
    }
 } else
    return false;
 return true;
}
?>

ringu
i try to find function that will show exists file in zip archive or not. of course i not found it. and so write mine:
first will just check archive for list of files, if not found all files function return FALSE:
function zipx_entries_exists()
{
$names=array();
$args=func_get_args();
$far_size=count($args);
if($args[0])
{
for(; $zip_entry=zip_read($args[0]); $names[]= zip_entry_name($zip_entry));
for($x=1; $x<=$far_size; $t+=in_array($args[$x], $names), $x++);
return $t==--$far_size;
}else{
return 'No zip file in descriptor!';
}  
}
example:
$zip=zip_open('any_zip_file_zip');
var_dump(zip_entries_exists($zip, 'photo_1.jpg', 'photo_2.jpg'));
second function will try to find files in zip, if not found it return string with names of not found files with specified delimeter:
function zipx_entries_nonexists_list()
{
$names=array();
$args=func_get_args();
$m=NULL;
$far_size=count($args);
if($args[0])
{
for(; $zip_entry=zip_read($args[0]); $names[]= zip_entry_name($zip_entry));
for($x=2; $x<=$far_size; $m.=(in_array($args[$x], $names) ? NULL : $args[$x].$args[1]), $x++);
return trim($m, $args[1]);
}else{
return 'No zip file in descriptor!';
}  
}
example:
$zip=zip_open('any_zip_file_zip');
var_dump(zip_entries_nonexists_list($zip, '<br />', 'photo_1.jpg', 'photo_2.jpg'));
it will return if not found files:
photo_1.jpg<br />photo_2.jpg

mishania
I slightly changed the extension of Schore that makes function operate more effiecently - less number of itterations. This is most important in dealing with HUGE archives.  I also add comment to brief the code.  Fits for WIN users.
function unzip($dir,$file) {
 $zip = zip_open($dir.$file.".zip"))
 if ($zip) {
   mkdir($dir.$file);
   while ($zip_entry = zip_read($zip)) {
     if (zip_entry_open($zip,$zip_entry,"r")) {
       $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
       $hostDir = dirname(zip_entry_name($zip_entry));
             /*  for root "." directory nothing to be done coase root directory was
                 created before the while-loop statement */
       if ($hostDir != ".") {
         $absPathToHostDir = $dir.$file."\\";
         
             /* Convrerts path string upon to FMS & OS-WIN configuration */
         foreach ( explode("/",$hostDir) as $k)
           $absPathToHostDir = $absPathToHostDir . $k . "\\";
         $absPathToHostDir = substr($absPathToHostDir,0,-1);
         
         if (is_file($absPathToHostDir))
           unlink($absPathToHostDir);
         if (!is_dir($absPathToHostDir))
           mkdir($absPathToHostDir);
             /* Stores Archive entries BOTH as file: Directories & Files;
                for this porpose we need these 2 hereabove [IF] checks  */
         $fp=fopen($dir.$file."\\".zip_entry_name($zip_entry),"w");
         fwrite($fp,$buf);
         fclose($fp);
         zip_entry_close($zip_entry);
       }
     }
     else  {
         echo "unable open - ";
         return false;
     }
   }  // while-loop end
   
   zip_close($zip);
 }
 else
    return false;
 return true;
}

nospam
I needed a quick way to make a zip file from an entire directory including subdirectories. This is downright rough but if someone would fancy it up a bit it works good with the zip class at http://smiledsoft.com/demos/phpzip/ (free version).
Basic use in script would be...
make_archive("the/directory", $zip_archive_object);
<?php
function make_archive( $dir , &$zip, $extdir="")
{
      if (is_dir($dir)) {
          if ($dh = opendir($dir)) {
              while (($file = readdir($dh)) !== false ) {
                      if( $file != "." && $file != ".." )
                      {
                              if( is_dir( $dir . $file ) )
                              {
                                          $zip->add_file($dir.$file,$extdir.$file);
                                           make_archive($dir.$file."/" , $zip, $extdir.$file."/");
                              }
                              else
                              {
           
                                          $zip->add_file($dir.$file,$extdir.$file);
                              }
                      }
              }
              closedir($dh);
          }
      }
return true;
}
?>

bushj
I made a zip stream handler in case your distribution does not have the built in one using the new ZipArchive system. This one also features the ability to grab entries by index as well as by name. It is similar in capabilities to the builtin gzip/bzip2 compression stream handlers (http://us2.php.net/manual/en/wrappers.compression.php) except it does not support writing.
To use:
fopen('zip://absolute/path/to/file.zip?entryname', $mode) or
fopen('zip://absolute/path/to/file.zip#entryindex', $mode) or
fopen('zip://absolute/path/to/file.zip', $mode)
$mode can only be 'r' or 'rb'. In the last case the first entry in the zip file is used.
<?php
class ZipStream {
 public $zip; //the zip file
 public $entry; //the opened zip entry
 public $length; //the uncompressed size of the zip entry
 public $position; //the current position in the zip entry read
 //Opens the zip file then retrieves and opens the entry to stream
 public function stream_open($path, $mode, $options, &$opened_path) {
   if ($mode != 'r' && $mode != 'rb') //only accept r and rb modes, no writing!
     return false;
   $path = 'file:///'.substr($path, 6); //switch out file:/// for zip:// so we can use url_parse
   $url = parse_url($path);
   //open the zip file
   $filename = $url['path'];
   $this->zip = zip_open($filename);
   if (!is_resource($this->zip))
     return false;
   //if entry name is given, find that entry    
   if (array_key_exists('query', $url) && $url['query']) {
     $path = $url['query'];
     do {
       $this->entry = zip_read($this->zip);
       if (!is_resource($this->entry))
         return false;
     } while (zip_entry_name($this->entry) != $path);    
   } else { //otherwise get it by index (default to 0)
     $id = 0;
     if (array_key_exists('fragment', $url) && is_int($url['fragment']))
       $id = $url['fragment']*1;
     for ($i = 0; $i <= $id; $i++) {
       $this->entry = zip_read($this->zip);
       if (!is_resource($this->entry))
         return false;
     }
   }
   //setup length and open the entry for reading
   $this->length = zip_entry_filesize($this->entry);
   $this->position = 0;
   zip_entry_open($this->zip, $this->entry, $mode);
   return true;
 }
 //Closes the zip entry and file
 public function stream_close() { @zip_entry_close($this->entry); @zip_close($this->zip); }
 //Returns how many bytes have been read from the zip entry
 public function stream_tell() { return $this->position; }
 //Returns true if the end of the zip entry has been reached
 public function stream_eof() { return $this->position >= $this->length; }
 //Returns the stat array, only 'size' is filled in with the uncompressed zip entry size
 public function url_stat() { return array('dev'=>0, 'ino'=>0, 'mode'=>0, 'nlink'=>0, 'uid'=>0, 'gid'=>0, 'rdev'=>0, 'size'=>$this->length, 'atime'=>0, 'mtime'=>0, 'ctime'=>0, 'blksize'=>0, 'blocks'=>0); }
 //Reads the next $count bytes or until the end of the zip entry. Returns the data or false if no data was read.
 public function stream_read($count) {
   $this->position += $count;
   if ($this->position > $this->length)
     $this->position = $this->length;
   return zip_entry_read($this->entry, $count);
 }
}
//Register the zip stream handler
stream_wrapper_register('zip', 'ZipStream'); //if this fails there is already a zip stream handler and we will just use that one
?>

postmaster
I have written an OpenSource ZIP2FTP interface, which actually takes a given ZIP file and decompresses it in the folder on an FTP server you specify...
Therefore it may be quite interesting for you people interested in ZIP, its adress is http://zip2ftp.alishomepage.com ; those who directly want the source may visit http://zip2ftp.alishomepage.com/?do=getSource

schore
I have had problems with the function of kristiankjaer to unpack zipfiles within any directories.
So I wrote a little extension.
<?php
function unpackZip($dir,$file) {
  if ($zip = zip_open($dir.$file.".zip")) {
    if ($zip) {
      mkdir($dir.$file);
      while ($zip_entry = zip_read($zip)) {
        if (zip_entry_open($zip,$zip_entry,"r")) {
          $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
       $dir_name = dirname(zip_entry_name($zip_entry));
          if ($dir_name != ".") {
            $dir_op = $dir.$file."/";
              foreach ( explode("/",$dir_name) as $k) {
                 $dir_op = $dir_op . $k;
                 if (is_file($dir_op)) unlink($dir_op);
                 if (!is_dir($dir_op)) mkdir($dir_op);
                 $dir_op = $dir_op . "/" ;
                 }
              }
          $fp=fopen($dir.$file."/".zip_entry_name($zip_entry),"w");
          fwrite($fp,$buf);
          zip_entry_close($zip_entry);
      } else
          return false;
      }
      zip_close($zip);
    }
 } else
    return false;
 return true;
}
?>

darkstream777
Hi,
i modified the function from nielsvandenberge, now you
can also use relative path's, i added also error messages
and another small highlights, have fun.
<?php
/**
* Unzip the source_file in the destination dir
*
* @param   string      The path to the ZIP-file.
* @param   string      The path where the zipfile should be unpacked, if false the directory of the zip-file is used
* @param   boolean     Indicates if the files will be unpacked in a directory with the name of the zip-file (true) or not (false) (only if the destination directory is set to false!)
* @param   boolean     Overwrite existing files (true) or not (false)
*
* @return  boolean     Succesful or not
*/
function unzip($src_file, $dest_dir=false, $create_zip_name_dir=true, $overwrite=true)
{
 if(function_exists("zip_open"))
 {  
     if(!is_resource(zip_open($src_file)))
     {
         $src_file=dirname($_SERVER['SCRIPT_FILENAME'])."/".$src_file;
     }
     
     if (is_resource($zip = zip_open($src_file)))
     {          
         $splitter = ($create_zip_name_dir === true) ? "." : "/";
         if ($dest_dir === false) $dest_dir = substr($src_file, 0, strrpos($src_file, $splitter))."/";
       
         // Create the directories to the destination dir if they don't already exist
         create_dirs($dest_dir);
         // For every file in the zip-packet
         while ($zip_entry = zip_read($zip))
         {
           // Now we're going to create the directories in the destination directories
         
           // If the file is not in the root dir
           $pos_last_slash = strrpos(zip_entry_name($zip_entry), "/");
           if ($pos_last_slash !== false)
           {
             // Create the directory where the zip-entry should be saved (with a "/" at the end)
             create_dirs($dest_dir.substr(zip_entry_name($zip_entry), 0, $pos_last_slash+1));
           }
           // Open the entry
           if (zip_entry_open($zip,$zip_entry,"r"))
           {
           
             // The name of the file to save on the disk
             $file_name = $dest_dir.zip_entry_name($zip_entry);
           
             // Check if the files should be overwritten or not
             if ($overwrite === true || $overwrite === false && !is_file($file_name))
             {
               // Get the content of the zip entry
               $fstream = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));          
               
               if(!is_dir($file_name))            
               file_put_contents($file_name, $fstream );
               // Set the rights
               if(file_exists($file_name))
               {
                   chmod($file_name, 0777);
                   echo "<span style=\"color:#1da319;\">file saved: </span>".$file_name."<br />";
               }
               else
               {
                   echo "<span style=\"color:red;\">file not found: </span>".$file_name."<br />";
               }
             }
           
             // Close the entry
             zip_entry_close($zip_entry);
           }      
         }
         // Close the zip-file
         zip_close($zip);
     }
     else
     {
       echo "No Zip Archive Found.";
       return false;
     }
   
     return true;
 }
 else
 {
     if(version_compare(phpversion(), "5.2.0", "<"))
     $infoVersion="(use PHP 5.2.0 or later)";
     
     echo "You need to install/enable the php_zip.dll extension $infoVersion";
 }
}
function create_dirs($path)
{
 if (!is_dir($path))
 {
   $directory_path = "";
   $directories = explode("/",$path);
   array_pop($directories);
 
   foreach($directories as $directory)
   {
     $directory_path .= $directory."/";
     if (!is_dir($directory_path))
     {
       mkdir($directory_path);
       chmod($directory_path, 0777);
     }
   }
 }
}
?>
greetings darki777

jeswanth@gmail
Hi, all
There are lot of functions given below which etracts files, but what they lack is setting file permissions. On some servers file permissions are very important and the script cease to work after creating first directory, So I have added chmod to the code. There is only one limitation to the code, files without file extension are neither treated as files or directories so they are not chmoded, anyway this does not affect the code. Hope this helps.
<?php
function unpackZip($dir,$file) {
  if ($zip = zip_open($dir.$file.".zip")) {
    if ($zip) {
      mkdir($dir.$file);
chmod($dir.$file, 0777);
      while ($zip_entry = zip_read($zip)) {
        if (zip_entry_open($zip,$zip_entry,"r")) {
          $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
          $dir_name = dirname(zip_entry_name($zip_entry));
          if ($dir_name != ".") {
            $dir_op = $dir.$file."/";
              foreach ( explode("/",$dir_name) as $k) {
                $dir_op = $dir_op . $k;
                if (is_file($dir_op)) unlink($dir_op);
                if (!is_dir($dir_op)) mkdir($dir_op);
chmod($dir_op, 0777);
                $dir_op = $dir_op . "/" ;
                }
              }
          $fp=fopen($dir.$file."/".zip_entry_name($zip_entry),"w+");
chmod($dir.$file."/".zip_entry_name($zip_entry), 0777);
          fwrite($fp,$buf);
          fclose($fp);
          zip_entry_close($zip_entry);
      } else
          return false;
      }
      zip_close($zip);
    }
 } else
    return false;
 return true;
}
$dir = $_SERVER['DOCUMENT_ROOT']."/"."destdirectory/";
$file = 'zipfilename_without_extension';
unpackZip($dir,$file);
$print = $_SERVER['DOCUMENT_ROOT'];
?>

master_auer
Hey guys, maybe you should check this out:
http://www.phpconcept.net/pclzip/index.en.php
A complete library to write and read ZIP files. The only requirement is zLib.
Hope I could help
Regards
Manuel

mmj48
Heres a function I wrote that will extract a zip file with the same directory structure...
Enjoy:
<?php
function unzip($zipfile)
{
$zip = zip_open($zipfile);
while ($zip_entry = zip_read($zip)) {
zip_entry_open($zip, $zip_entry);
if (substr(zip_entry_name($zip_entry), -1) == '/') {
$zdir = substr(zip_entry_name($zip_entry), 0, -1);
if (file_exists($zdir)) {
trigger_error('Directory "<b>' . $zdir . '</b>" exists', E_USER_ERROR);
return false;
}
mkdir($zdir);
}
else {
$name = zip_entry_name($zip_entry);
if (file_exists($name)) {
trigger_error('File "<b>' . $name . '</b>" exists', E_USER_ERROR);
return false;
}
$fopen = fopen($name, "w");
fwrite($fopen, zip_entry_read($zip_entry, zip_entry_filesize($zip_entry)), zip_entry_filesize($zip_entry));
}
zip_entry_close($zip_entry);
}
zip_close($zip);
return true;
}
?>

bermi arroba akelos.com
Here is a link to a class for creating and reading zip files
http://www.phpconcept.net/pclzip/

kristiankjaer
Here is a function if all you need is to unpack an archive:
function unpackZip($dir,$file) {
$root=$_SERVER['DOCUMENT_ROOT'];
if ($zip = zip_open($root.$dir.$file.".zip")) {
 if ($zip) {
    mkdir(".".$dir.$file);
   while ($zip_entry = zip_read($zip)) {
      if (zip_entry_open($zip,$zip_entry,"r")) {
       $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
       $fp=fopen(".".$dir.$file."/".zip_entry_name($zip_entry),"w");
       fwrite($fp,$buf);
       zip_entry_close($zip_entry);
       } else
        return false;
   }
   zip_close($zip);
 }
 } else
  return false;
 return true;
}

vbwebprofi
For more informations about the ZIP-format visit this document :
http://www.pkware.com/products/enterprise/white_papers/appnote.html
So you be able to write your own ZIP and UNZIP code ... ;o)
Regards
Holger

a1cypher
For creating zip files, I highly suggest that you have a look at the class used in phpMyAdmin.  It makes it very easy to do and it appears to be opensource.

fbiggun
Check out these pages on the Zend Web Site. The author of the zipfile class explains how his class runs!
Have fun ;)
http://www.zend.com/zend/spotlight/creating-zip-files1.php
http://www.zend.com/zend/spotlight/creating-zip-files2.php
http://www.zend.com/zend/spotlight/creating-zip-files3.php

hannes gassert
As of lately this extension has moved to PECL. You find it at it's new home at http://pecl.php.net/package/zip.
`pear install http://pecl.php.net/get/zip-1.0.tgz ` installs it, use dl('zip.so'); to load it after successful installation.

phpcontrib a t esurfers d o t com
1) A warning to all users of PHP Zipping/Unzipping Classes: most of them require the whole content of the ZIP file and/or the unzipped contents to stay in memory. They work very well, but might fail with very large files. Keep this in mind before starting development of a project involving large ZIP files.
2) If all you need is to unzip files to a folder, and your server has a zip command line tool, all you might need is a function like this:
if(!defined('UNZIP_CMD')) define('UNZIP_CMD','unzip -o @_SRC_@ -x -d  
@_DST_@');
function UnzipAllFiles($zipFile,$zipDir) {
$unzipCmd=UNZIP_CMD;
$unzipCmd=str_replace('@_SRC_@',$zipFile,$unzipCmd);
$unzipCmd=str_replace('@_DST_@',$zipDir,$unzipCmd);
$res=-1; // any nonzero value
$UnusedArrayResult=array();
$UnusedStringResult=exec($unzipCmd,$UnusedArrayResult,$res);
return ($res==0);
}
// * * *  You DO NOT NEED the ZIP lib or M-ZIP to use this, but you will need the tool M-ZIP uses (unzip.exe or unzip for linux).  * * *
// Use it this way:
$zipFile='/path/to/uploaded_file.zip';
$whereToUnzip='/path/to/writable/folder/';
$result=UnzipAllFiles($zipFile,$whereToUnzip);
if($result===FALSE) echo('FAILED');
else echo('SUCCESS');
By changing UNZIP_CMD (the same constant as in the m-zip lib) you can  
of course untar, unarc, unrar, etc... provided you have the correct  
unwhatever command or unwhatever.exe executable and write its correct syntax in UNZIP_CMD.
To see details of what tools you need and where to put them (or to use a syntax compatible to the standard zip lib) see http://eSurfers.com/m-zip/

guidod
- look at - http://zipios.sf.net -
it is a C++ class that can also write zip files.
it is modelled after the resp. java interface.
Please also note that I (Guido Draheim) can not
answer questions on compiling zziplib-support
into php, I did not add it, and I do not know
anything about the php module interface. If you
find bugs or have suggestions for more features
then I would be pleased to hear about it. TIA, guido

joris p.
"If you just want to unzip everything of a zip file in a directory"
Watch out with that function, your fopen function uses 'r' instead of 'rb' and the fwrite does not include a filesize. So if you have binary files into that zip file (what you probably do), it will go wrong...

Change Language


Follow Navioo On Twitter
.NET Functions
Apache-specific Functions
Alternative PHP Cache
Advanced PHP debugger
Array Functions
Aspell functions [deprecated]
BBCode Functions
BCMath Arbitrary Precision Mathematics Functions
PHP bytecode Compiler
Bzip2 Compression Functions
Calendar Functions
CCVS API Functions [deprecated]
Class/Object Functions
Classkit Functions
ClibPDF Functions [deprecated]
COM and .Net (Windows)
Crack Functions
Character Type Functions
CURL
Cybercash Payment Functions
Credit Mutuel CyberMUT functions
Cyrus IMAP administration Functions
Date and Time Functions
DB++ Functions
Database (dbm-style) Abstraction Layer Functions
dBase Functions
DBM Functions [deprecated]
dbx Functions
Direct IO Functions
Directory Functions
DOM Functions
DOM XML Functions
enchant Functions
Error Handling and Logging Functions
Exif Functions
Expect Functions
File Alteration Monitor Functions
Forms Data Format Functions
Fileinfo Functions
filePro Functions
Filesystem Functions
Filter Functions
Firebird/InterBase Functions
Firebird/Interbase Functions (PDO_FIREBIRD)
FriBiDi Functions
FrontBase Functions
FTP Functions
Function Handling Functions
GeoIP Functions
Gettext Functions
GMP Functions
gnupg Functions
Net_Gopher
Haru PDF Functions
hash Functions
HTTP
Hyperwave Functions
Hyperwave API Functions
i18n Functions
IBM Functions (PDO_IBM)
IBM DB2
iconv Functions
ID3 Functions
IIS Administration Functions
Image Functions
Imagick Image Library
IMAP
Informix Functions
Informix Functions (PDO_INFORMIX)
Ingres II Functions
IRC Gateway Functions
PHP / Java Integration
JSON Functions
KADM5
LDAP Functions
libxml Functions
Lotus Notes Functions
LZF Functions
Mail Functions
Mailparse Functions
Mathematical Functions
MaxDB PHP Extension
MCAL Functions
Mcrypt Encryption Functions
MCVE (Monetra) Payment Functions
Memcache Functions
Mhash Functions
Mimetype Functions
Ming functions for Flash
Miscellaneous Functions
mnoGoSearch Functions
Microsoft SQL Server Functions
Microsoft SQL Server and Sybase Functions (PDO_DBLIB)
Mohawk Software Session Handler Functions
mSQL Functions
Multibyte String Functions
muscat Functions
MySQL Functions
MySQL Functions (PDO_MYSQL)
MySQL Improved Extension
Ncurses Terminal Screen Control Functions
Network Functions
Newt Functions
NSAPI-specific Functions
Object Aggregation/Composition Functions
Object property and method call overloading
Oracle Functions
ODBC Functions (Unified)
ODBC and DB2 Functions (PDO_ODBC)
oggvorbis
OpenAL Audio Bindings
OpenSSL Functions
Oracle Functions [deprecated]
Oracle Functions (PDO_OCI)
Output Control Functions
Ovrimos SQL Functions
Paradox File Access
Parsekit Functions
Process Control Functions
Regular Expression Functions (Perl-Compatible)
PDF Functions
PDO Functions
Phar archive stream and classes
PHP Options&Information
POSIX Functions
Regular Expression Functions (POSIX Extended)
PostgreSQL Functions
PostgreSQL Functions (PDO_PGSQL)
Printer Functions
Program Execution Functions
PostScript document creation
Pspell Functions
qtdom Functions
Radius
Rar Functions
GNU Readline
GNU Recode Functions
RPM Header Reading Functions
runkit Functions
SAM - Simple Asynchronous Messaging
Satellite CORBA client extension [deprecated]
SCA Functions
SDO Functions
SDO XML Data Access Service Functions
SDO Relational Data Access Service Functions
Semaphore
SESAM Database Functions
PostgreSQL Session Save Handler
Session Handling Functions
Shared Memory Functions
SimpleXML functions
SNMP Functions
SOAP Functions
Socket Functions
Standard PHP Library (SPL) Functions
SQLite Functions
SQLite Functions (PDO_SQLITE)
Secure Shell2 Functions
Statistics Functions
Stream Functions
String Functions
Subversion Functions
Shockwave Flash Functions
Swish Functions
Sybase Functions
TCP Wrappers Functions
Tidy Functions
Tokenizer Functions
Unicode Functions
URL Functions
Variable Handling Functions
Verisign Payflow Pro Functions
vpopmail Functions
W32api Functions
WDDX Functions
win32ps Functions
win32service Functions
xattr Functions
xdiff Functions
XML Parser Functions
XML-RPC Functions
XMLReader functions
XMLWriter Functions
XSL functions
XSLT Functions
YAZ Functions
YP/NIS Functions
Zip File Functions
Zlib Compression Functions
Terms of Service Privacy Policy Sitemap

©2024 -EPSILONSYS SOFTWARE inc

Other EPSILONSYS SOFTWARE Web Sites : Programming Resources | News Headline | Free local classifieds

eXTReMe Tracker