1 <?php

     2 // --------------------------------------------------------------------------------

     3 // PhpConcept Library - Zip Module 2.8.2

     4 // --------------------------------------------------------------------------------

     5 // License GNU/LGPL - Vincent Blavet - August 2009

     6 // http://www.phpconcept.net

     7 // --------------------------------------------------------------------------------

     8 //

     9 // Presentation :

    10 //   PclZip is a PHP library that manage ZIP archives.

    11 //   So far tests show that archives generated by PclZip are readable by

    12 //   WinZip application and other tools.

    13 //

    14 // Description :

    15 //   See readme.txt and http://www.phpconcept.net

    16 //

    17 // Warning :

    18 //   This library and the associated files are non commercial, non professional

    19 //   work.

    20 //   It should not have unexpected results. However if any damage is caused by

    21 //   this software the author can not be responsible.

    22 //   The use of this software is at the risk of the user.

    23 //

    24 // --------------------------------------------------------------------------------

    25 // $Id: pclzip.lib.php,v 1.60 2009/09/30 21:01:04 vblavet Exp $

    26 // --------------------------------------------------------------------------------

    27 

    28   // ----- Constants

    29   if (!defined('PCLZIP_READ_BLOCK_SIZE')) {

    30     define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );

    31   }

    32 

    33   // ----- File list separator

    34   // In version 1.x of PclZip, the separator for file list is a space

    35   // (which is not a very smart choice, specifically for windows paths !).

    36   // A better separator should be a comma (,). This constant gives you the

    37   // abilty to change that.

    38   // However notice that changing this value, may have impact on existing

    39   // scripts, using space separated filenames.

    40   // Recommanded values for compatibility with older versions :

    41   //define( 'PCLZIP_SEPARATOR', ' ' );

    42   // Recommanded values for smart separation of filenames.

    43   if (!defined('PCLZIP_SEPARATOR')) {

    44     define( 'PCLZIP_SEPARATOR', ',' );

    45   }

    46 

    47   // ----- Error configuration

    48   // 0 : PclZip Class integrated error handling

    49   // 1 : PclError external library error handling. By enabling this

    50   //     you must ensure that you have included PclError library.

    51   // [2,...] : reserved for futur use

    52   if (!defined('PCLZIP_ERROR_EXTERNAL')) {

    53     define( 'PCLZIP_ERROR_EXTERNAL', 0 );

    54   }

    55 

    56   // ----- Optional static temporary directory

    57   //       By default temporary files are generated in the script current

    58   //       path.

    59   //       If defined :

    60   //       - MUST BE terminated by a '/'.

    61   //       - MUST be a valid, already created directory

    62   //       Samples :

    63   // define( 'PCLZIP_TEMPORARY_DIR', '/temp/' );

    64   // define( 'PCLZIP_TEMPORARY_DIR', 'C:/Temp/' );

    65   if (!defined('PCLZIP_TEMPORARY_DIR')) {

    66     define( 'PCLZIP_TEMPORARY_DIR', '' );

    67   }

    68 

    69   // ----- Optional threshold ratio for use of temporary files

    70   //       Pclzip sense the size of the file to add/extract and decide to

    71   //       use or not temporary file. The algorythm is looking for

    72   //       memory_limit of PHP and apply a ratio.

    73   //       threshold = memory_limit * ratio.

    74   //       Recommended values are under 0.5. Default 0.47.

    75   //       Samples :

    76   // define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.5 );

    77   if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {

    78     define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );

    79   }

    80 

    81 // --------------------------------------------------------------------------------

    82 // ***** UNDER THIS LINE NOTHING NEEDS TO BE MODIFIED *****

    83 // --------------------------------------------------------------------------------

    84 

    85   // ----- Global variables

    86   $g_pclzip_version = "2.8.2";

    87 

    88   // ----- Error codes

    89   //   -1 : Unable to open file in binary write mode

    90   //   -2 : Unable to open file in binary read mode

    91   //   -3 : Invalid parameters

    92   //   -4 : File does not exist

    93   //   -5 : Filename is too long (max. 255)

    94   //   -6 : Not a valid zip file

    95   //   -7 : Invalid extracted file size

    96   //   -8 : Unable to create directory

    97   //   -9 : Invalid archive extension

    98   //  -10 : Invalid archive format

    99   //  -11 : Unable to delete file (unlink)

   100   //  -12 : Unable to rename file (rename)

   101   //  -13 : Invalid header checksum

   102   //  -14 : Invalid archive size

   103   define( 'PCLZIP_ERR_USER_ABORTED', 2 );

   104   define( 'PCLZIP_ERR_NO_ERROR', 0 );

   105   define( 'PCLZIP_ERR_WRITE_OPEN_FAIL', -1 );

   106   define( 'PCLZIP_ERR_READ_OPEN_FAIL', -2 );

   107   define( 'PCLZIP_ERR_INVALID_PARAMETER', -3 );

   108   define( 'PCLZIP_ERR_MISSING_FILE', -4 );

   109   define( 'PCLZIP_ERR_FILENAME_TOO_LONG', -5 );

   110   define( 'PCLZIP_ERR_INVALID_ZIP', -6 );

   111   define( 'PCLZIP_ERR_BAD_EXTRACTED_FILE', -7 );

   112   define( 'PCLZIP_ERR_DIR_CREATE_FAIL', -8 );

   113   define( 'PCLZIP_ERR_BAD_EXTENSION', -9 );

   114   define( 'PCLZIP_ERR_BAD_FORMAT', -10 );

   115   define( 'PCLZIP_ERR_DELETE_FILE_FAIL', -11 );

   116   define( 'PCLZIP_ERR_RENAME_FILE_FAIL', -12 );

   117   define( 'PCLZIP_ERR_BAD_CHECKSUM', -13 );

   118   define( 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP', -14 );

   119   define( 'PCLZIP_ERR_MISSING_OPTION_VALUE', -15 );

   120   define( 'PCLZIP_ERR_INVALID_OPTION_VALUE', -16 );

   121   define( 'PCLZIP_ERR_ALREADY_A_DIRECTORY', -17 );

   122   define( 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION', -18 );

   123   define( 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION', -19 );

   124   define( 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE', -20 );

   125   define( 'PCLZIP_ERR_DIRECTORY_RESTRICTION', -21 );

   126 

   127   // ----- Options values

   128   define( 'PCLZIP_OPT_PATH', 77001 );

   129   define( 'PCLZIP_OPT_ADD_PATH', 77002 );

   130   define( 'PCLZIP_OPT_REMOVE_PATH', 77003 );

   131   define( 'PCLZIP_OPT_REMOVE_ALL_PATH', 77004 );

   132   define( 'PCLZIP_OPT_SET_CHMOD', 77005 );

   133   define( 'PCLZIP_OPT_EXTRACT_AS_STRING', 77006 );

   134   define( 'PCLZIP_OPT_NO_COMPRESSION', 77007 );

   135   define( 'PCLZIP_OPT_BY_NAME', 77008 );

   136   define( 'PCLZIP_OPT_BY_INDEX', 77009 );

   137   define( 'PCLZIP_OPT_BY_EREG', 77010 );

   138   define( 'PCLZIP_OPT_BY_PREG', 77011 );

   139   define( 'PCLZIP_OPT_COMMENT', 77012 );

   140   define( 'PCLZIP_OPT_ADD_COMMENT', 77013 );

   141   define( 'PCLZIP_OPT_PREPEND_COMMENT', 77014 );

   142   define( 'PCLZIP_OPT_EXTRACT_IN_OUTPUT', 77015 );

   143   define( 'PCLZIP_OPT_REPLACE_NEWER', 77016 );

   144   define( 'PCLZIP_OPT_STOP_ON_ERROR', 77017 );

   145   // Having big trouble with crypt. Need to multiply 2 long int

   146   // which is not correctly supported by PHP ...

   147   //define( 'PCLZIP_OPT_CRYPT', 77018 );

   148   define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );

   149   define( 'PCLZIP_OPT_TEMP_FILE_THRESHOLD', 77020 );

   150   define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 ); // alias

   151   define( 'PCLZIP_OPT_TEMP_FILE_ON', 77021 );

   152   define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 ); // alias

   153   define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );

   154   define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 ); // alias

   155 

   156   // ----- File description attributes

   157   define( 'PCLZIP_ATT_FILE_NAME', 79001 );

   158   define( 'PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002 );

   159   define( 'PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003 );

   160   define( 'PCLZIP_ATT_FILE_MTIME', 79004 );

   161   define( 'PCLZIP_ATT_FILE_CONTENT', 79005 );

   162   define( 'PCLZIP_ATT_FILE_COMMENT', 79006 );

   163 

   164   // ----- Call backs values

   165   define( 'PCLZIP_CB_PRE_EXTRACT', 78001 );

   166   define( 'PCLZIP_CB_POST_EXTRACT', 78002 );

   167   define( 'PCLZIP_CB_PRE_ADD', 78003 );

   168   define( 'PCLZIP_CB_POST_ADD', 78004 );

   169   /* For futur use

   170   define( 'PCLZIP_CB_PRE_LIST', 78005 );

   171   define( 'PCLZIP_CB_POST_LIST', 78006 );

   172   define( 'PCLZIP_CB_PRE_DELETE', 78007 );

   173   define( 'PCLZIP_CB_POST_DELETE', 78008 );

   174   */

   175 

   176   // --------------------------------------------------------------------------------

   177   // Class : PclZip

   178   // Description :

   179   //   PclZip is the class that represent a Zip archive.

   180   //   The public methods allow the manipulation of the archive.

   181   // Attributes :

   182   //   Attributes must not be accessed directly.

   183   // Methods :

   184   //   PclZip() : Object creator

   185   //   create() : Creates the Zip archive

   186   //   listContent() : List the content of the Zip archive

   187   //   extract() : Extract the content of the archive

   188   //   properties() : List the properties of the archive

   189   // --------------------------------------------------------------------------------

   190   class PclZip

   191   {

   192     // ----- Filename of the zip file

   193     var $zipname = '';

   194 

   195     // ----- File descriptor of the zip file

   196     var $zip_fd = 0;

   197 

   198     // ----- Internal error handling

   199     var $error_code = 1;

   200     var $error_string = '';

   201 

   202     // ----- Current status of the magic_quotes_runtime

   203     // This value store the php configuration for magic_quotes

   204     // The class can then disable the magic_quotes and reset it after

   205     var $magic_quotes_status;

   206 

   207   // --------------------------------------------------------------------------------

   208   // Function : PclZip()

   209   // Description :

   210   //   Creates a PclZip object and set the name of the associated Zip archive

   211   //   filename.

   212   //   Note that no real action is taken, if the archive does not exist it is not

   213   //   created. Use create() for that.

   214   // --------------------------------------------------------------------------------

   215   function PclZip($p_zipname)

   216   {

   217 

   218     // ----- Tests the zlib

   219     if (!function_exists('gzopen'))

   220     {

   221       die('Abort '.basename(__FILE__).' : Missing zlib extensions');

   222     }

   223 

   224     // ----- Set the attributes

   225     $this->zipname = $p_zipname;

   226     $this->zip_fd = 0;

   227     $this->magic_quotes_status = -1;

   228 

   229     // ----- Return

   230     return;

   231   }

   232   // --------------------------------------------------------------------------------

   233 

   234   // --------------------------------------------------------------------------------

   235   // Function :

   236   //   create($p_filelist, $p_add_dir="", $p_remove_dir="")

   237   //   create($p_filelist, $p_option, $p_option_value, ...)

   238   // Description :

   239   //   This method supports two different synopsis. The first one is historical.

   240   //   This method creates a Zip Archive. The Zip file is created in the

   241   //   filesystem. The files and directories indicated in $p_filelist

   242   //   are added in the archive. See the parameters description for the

   243   //   supported format of $p_filelist.

   244   //   When a directory is in the list, the directory and its content is added

   245   //   in the archive.

   246   //   In this synopsis, the function takes an optional variable list of

   247   //   options. See bellow the supported options.

   248   // Parameters :

   249   //   $p_filelist : An array containing file or directory names, or

   250   //                 a string containing one filename or one directory name, or

   251   //                 a string containing a list of filenames and/or directory

   252   //                 names separated by spaces.

   253   //   $p_add_dir : A path to add before the real path of the archived file,

   254   //                in order to have it memorized in the archive.

   255   //   $p_remove_dir : A path to remove from the real path of the file to archive,

   256   //                   in order to have a shorter path memorized in the archive.

   257   //                   When $p_add_dir and $p_remove_dir are set, $p_remove_dir

   258   //                   is removed first, before $p_add_dir is added.

   259   // Options :

   260   //   PCLZIP_OPT_ADD_PATH :

   261   //   PCLZIP_OPT_REMOVE_PATH :

   262   //   PCLZIP_OPT_REMOVE_ALL_PATH :

   263   //   PCLZIP_OPT_COMMENT :

   264   //   PCLZIP_CB_PRE_ADD :

   265   //   PCLZIP_CB_POST_ADD :

   266   // Return Values :

   267   //   0 on failure,

   268   //   The list of the added files, with a status of the add action.

   269   //   (see PclZip::listContent() for list entry format)

   270   // --------------------------------------------------------------------------------

   271   function create($p_filelist)

   272   {

   273     $v_result=1;

   274 

   275     // ----- Reset the error handler

   276     $this->privErrorReset();

   277 

   278     // ----- Set default values

   279     $v_options = array();

   280     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;

   281 

   282     // ----- Look for variable options arguments

   283     $v_size = func_num_args();

   284 

   285     // ----- Look for arguments

   286     if ($v_size > 1) {

   287       // ----- Get the arguments

   288       $v_arg_list = func_get_args();

   289 

   290       // ----- Remove from the options list the first argument

   291       array_shift($v_arg_list);

   292       $v_size--;

   293 

   294       // ----- Look for first arg

   295       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

   296 

   297         // ----- Parse the options

   298         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

   299                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',

   300                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',

   301                                                    PCLZIP_OPT_ADD_PATH => 'optional',

   302                                                    PCLZIP_CB_PRE_ADD => 'optional',

   303                                                    PCLZIP_CB_POST_ADD => 'optional',

   304                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',

   305                                                    PCLZIP_OPT_COMMENT => 'optional',

   306                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',

   307                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',

   308                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'

   309                                                    //, PCLZIP_OPT_CRYPT => 'optional'

   310                                              ));

   311         if ($v_result != 1) {

   312           return 0;

   313         }

   314       }

   315 

   316       // ----- Look for 2 args

   317       // Here we need to support the first historic synopsis of the

   318       // method.

   319       else {

   320 

   321         // ----- Get the first argument

   322         $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];

   323 

   324         // ----- Look for the optional second argument

   325         if ($v_size == 2) {

   326           $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];

   327         }

   328         else if ($v_size > 2) {

   329           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,

   330 		                       "Invalid number / type of arguments");

   331           return 0;

   332         }

   333       }

   334     }

   335 

   336     // ----- Look for default option values

   337     $this->privOptionDefaultThreshold($v_options);

   338 

   339     // ----- Init

   340     $v_string_list = array();

   341     $v_att_list = array();

   342     $v_filedescr_list = array();

   343     $p_result_list = array();

   344 

   345     // ----- Look if the $p_filelist is really an array

   346     if (is_array($p_filelist)) {

   347 

   348       // ----- Look if the first element is also an array

   349       //       This will mean that this is a file description entry

   350       if (isset($p_filelist[0]) && is_array($p_filelist[0])) {

   351         $v_att_list = $p_filelist;

   352       }

   353 

   354       // ----- The list is a list of string names

   355       else {

   356         $v_string_list = $p_filelist;

   357       }

   358     }

   359 

   360     // ----- Look if the $p_filelist is a string

   361     else if (is_string($p_filelist)) {

   362       // ----- Create a list from the string

   363       $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);

   364     }

   365 

   366     // ----- Invalid variable type for $p_filelist

   367     else {

   368       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");

   369       return 0;

   370     }

   371 

   372     // ----- Reformat the string list

   373     if (sizeof($v_string_list) != 0) {

   374       foreach ($v_string_list as $v_string) {

   375         if ($v_string != '') {

   376           $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;

   377         }

   378         else {

   379         }

   380       }

   381     }

   382 

   383     // ----- For each file in the list check the attributes

   384     $v_supported_attributes

   385     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'

   386              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'

   387              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'

   388              ,PCLZIP_ATT_FILE_MTIME => 'optional'

   389              ,PCLZIP_ATT_FILE_CONTENT => 'optional'

   390              ,PCLZIP_ATT_FILE_COMMENT => 'optional'

   391 						);

   392     foreach ($v_att_list as $v_entry) {

   393       $v_result = $this->privFileDescrParseAtt($v_entry,

   394                                                $v_filedescr_list[],

   395                                                $v_options,

   396                                                $v_supported_attributes);

   397       if ($v_result != 1) {

   398         return 0;

   399       }

   400     }

   401 

   402     // ----- Expand the filelist (expand directories)

   403     $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);

   404     if ($v_result != 1) {

   405       return 0;

   406     }

   407 

   408     // ----- Call the create fct

   409     $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);

   410     if ($v_result != 1) {

   411       return 0;

   412     }

   413 

   414     // ----- Return

   415     return $p_result_list;

   416   }

   417   // --------------------------------------------------------------------------------

   418 

   419   // --------------------------------------------------------------------------------

   420   // Function :

   421   //   add($p_filelist, $p_add_dir="", $p_remove_dir="")

   422   //   add($p_filelist, $p_option, $p_option_value, ...)

   423   // Description :

   424   //   This method supports two synopsis. The first one is historical.

   425   //   This methods add the list of files in an existing archive.

   426   //   If a file with the same name already exists, it is added at the end of the

   427   //   archive, the first one is still present.

   428   //   If the archive does not exist, it is created.

   429   // Parameters :

   430   //   $p_filelist : An array containing file or directory names, or

   431   //                 a string containing one filename or one directory name, or

   432   //                 a string containing a list of filenames and/or directory

   433   //                 names separated by spaces.

   434   //   $p_add_dir : A path to add before the real path of the archived file,

   435   //                in order to have it memorized in the archive.

   436   //   $p_remove_dir : A path to remove from the real path of the file to archive,

   437   //                   in order to have a shorter path memorized in the archive.

   438   //                   When $p_add_dir and $p_remove_dir are set, $p_remove_dir

   439   //                   is removed first, before $p_add_dir is added.

   440   // Options :

   441   //   PCLZIP_OPT_ADD_PATH :

   442   //   PCLZIP_OPT_REMOVE_PATH :

   443   //   PCLZIP_OPT_REMOVE_ALL_PATH :

   444   //   PCLZIP_OPT_COMMENT :

   445   //   PCLZIP_OPT_ADD_COMMENT :

   446   //   PCLZIP_OPT_PREPEND_COMMENT :

   447   //   PCLZIP_CB_PRE_ADD :

   448   //   PCLZIP_CB_POST_ADD :

   449   // Return Values :

   450   //   0 on failure,

   451   //   The list of the added files, with a status of the add action.

   452   //   (see PclZip::listContent() for list entry format)

   453   // --------------------------------------------------------------------------------

   454   function add($p_filelist)

   455   {

   456     $v_result=1;

   457 

   458     // ----- Reset the error handler

   459     $this->privErrorReset();

   460 

   461     // ----- Set default values

   462     $v_options = array();

   463     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;

   464 

   465     // ----- Look for variable options arguments

   466     $v_size = func_num_args();

   467 

   468     // ----- Look for arguments

   469     if ($v_size > 1) {

   470       // ----- Get the arguments

   471       $v_arg_list = func_get_args();

   472 

   473       // ----- Remove form the options list the first argument

   474       array_shift($v_arg_list);

   475       $v_size--;

   476 

   477       // ----- Look for first arg

   478       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

   479 

   480         // ----- Parse the options

   481         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

   482                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',

   483                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',

   484                                                    PCLZIP_OPT_ADD_PATH => 'optional',

   485                                                    PCLZIP_CB_PRE_ADD => 'optional',

   486                                                    PCLZIP_CB_POST_ADD => 'optional',

   487                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',

   488                                                    PCLZIP_OPT_COMMENT => 'optional',

   489                                                    PCLZIP_OPT_ADD_COMMENT => 'optional',

   490                                                    PCLZIP_OPT_PREPEND_COMMENT => 'optional',

   491                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',

   492                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',

   493                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'

   494                                                    //, PCLZIP_OPT_CRYPT => 'optional'

   495 												   ));

   496         if ($v_result != 1) {

   497           return 0;

   498         }

   499       }

   500 

   501       // ----- Look for 2 args

   502       // Here we need to support the first historic synopsis of the

   503       // method.

   504       else {

   505 

   506         // ----- Get the first argument

   507         $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];

   508 

   509         // ----- Look for the optional second argument

   510         if ($v_size == 2) {

   511           $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];

   512         }

   513         else if ($v_size > 2) {

   514           // ----- Error log

   515           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");

   516 

   517           // ----- Return

   518           return 0;

   519         }

   520       }

   521     }

   522 

   523     // ----- Look for default option values

   524     $this->privOptionDefaultThreshold($v_options);

   525 

   526     // ----- Init

   527     $v_string_list = array();

   528     $v_att_list = array();

   529     $v_filedescr_list = array();

   530     $p_result_list = array();

   531 

   532     // ----- Look if the $p_filelist is really an array

   533     if (is_array($p_filelist)) {

   534 

   535       // ----- Look if the first element is also an array

   536       //       This will mean that this is a file description entry

   537       if (isset($p_filelist[0]) && is_array($p_filelist[0])) {

   538         $v_att_list = $p_filelist;

   539       }

   540 

   541       // ----- The list is a list of string names

   542       else {

   543         $v_string_list = $p_filelist;

   544       }

   545     }

   546 

   547     // ----- Look if the $p_filelist is a string

   548     else if (is_string($p_filelist)) {

   549       // ----- Create a list from the string

   550       $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);

   551     }

   552 

   553     // ----- Invalid variable type for $p_filelist

   554     else {

   555       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");

   556       return 0;

   557     }

   558 

   559     // ----- Reformat the string list

   560     if (sizeof($v_string_list) != 0) {

   561       foreach ($v_string_list as $v_string) {

   562         $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;

   563       }

   564     }

   565 

   566     // ----- For each file in the list check the attributes

   567     $v_supported_attributes

   568     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'

   569              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'

   570              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'

   571              ,PCLZIP_ATT_FILE_MTIME => 'optional'

   572              ,PCLZIP_ATT_FILE_CONTENT => 'optional'

   573              ,PCLZIP_ATT_FILE_COMMENT => 'optional'

   574 						);

   575     foreach ($v_att_list as $v_entry) {

   576       $v_result = $this->privFileDescrParseAtt($v_entry,

   577                                                $v_filedescr_list[],

   578                                                $v_options,

   579                                                $v_supported_attributes);

   580       if ($v_result != 1) {

   581         return 0;

   582       }

   583     }

   584 

   585     // ----- Expand the filelist (expand directories)

   586     $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);

   587     if ($v_result != 1) {

   588       return 0;

   589     }

   590 

   591     // ----- Call the create fct

   592     $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);

   593     if ($v_result != 1) {

   594       return 0;

   595     }

   596 

   597     // ----- Return

   598     return $p_result_list;

   599   }

   600   // --------------------------------------------------------------------------------

   601 

   602   // --------------------------------------------------------------------------------

   603   // Function : listContent()

   604   // Description :

   605   //   This public method, gives the list of the files and directories, with their

   606   //   properties.

   607   //   The properties of each entries in the list are (used also in other functions) :

   608   //     filename : Name of the file. For a create or add action it is the filename

   609   //                given by the user. For an extract function it is the filename

   610   //                of the extracted file.

   611   //     stored_filename : Name of the file / directory stored in the archive.

   612   //     size : Size of the stored file.

   613   //     compressed_size : Size of the file's data compressed in the archive

   614   //                       (without the headers overhead)

   615   //     mtime : Last known modification date of the file (UNIX timestamp)

   616   //     comment : Comment associated with the file

   617   //     folder : true | false

   618   //     index : index of the file in the archive

   619   //     status : status of the action (depending of the action) :

   620   //              Values are :

   621   //                ok : OK !

   622   //                filtered : the file / dir is not extracted (filtered by user)

   623   //                already_a_directory : the file can not be extracted because a

   624   //                                      directory with the same name already exists

   625   //                write_protected : the file can not be extracted because a file

   626   //                                  with the same name already exists and is

   627   //                                  write protected

   628   //                newer_exist : the file was not extracted because a newer file exists

   629   //                path_creation_fail : the file is not extracted because the folder

   630   //                                     does not exist and can not be created

   631   //                write_error : the file was not extracted because there was a

   632   //                              error while writing the file

   633   //                read_error : the file was not extracted because there was a error

   634   //                             while reading the file

   635   //                invalid_header : the file was not extracted because of an archive

   636   //                                 format error (bad file header)

   637   //   Note that each time a method can continue operating when there

   638   //   is an action error on a file, the error is only logged in the file status.

   639   // Return Values :

   640   //   0 on an unrecoverable failure,

   641   //   The list of the files in the archive.

   642   // --------------------------------------------------------------------------------

   643   function listContent()

   644   {

   645     $v_result=1;

   646 

   647     // ----- Reset the error handler

   648     $this->privErrorReset();

   649 

   650     // ----- Check archive

   651     if (!$this->privCheckFormat()) {

   652       return(0);

   653     }

   654 

   655     // ----- Call the extracting fct

   656     $p_list = array();

   657     if (($v_result = $this->privList($p_list)) != 1)

   658     {

   659       unset($p_list);

   660       return(0);

   661     }

   662 

   663     // ----- Return

   664     return $p_list;

   665   }

   666   // --------------------------------------------------------------------------------

   667 

   668   // --------------------------------------------------------------------------------

   669   // Function :

   670   //   extract($p_path="./", $p_remove_path="")

   671   //   extract([$p_option, $p_option_value, ...])

   672   // Description :

   673   //   This method supports two synopsis. The first one is historical.

   674   //   This method extract all the files / directories from the archive to the

   675   //   folder indicated in $p_path.

   676   //   If you want to ignore the 'root' part of path of the memorized files

   677   //   you can indicate this in the optional $p_remove_path parameter.

   678   //   By default, if a newer file with the same name already exists, the

   679   //   file is not extracted.

   680   //

   681   //   If both PCLZIP_OPT_PATH and PCLZIP_OPT_ADD_PATH aoptions

   682   //   are used, the path indicated in PCLZIP_OPT_ADD_PATH is append

   683   //   at the end of the path value of PCLZIP_OPT_PATH.

   684   // Parameters :

   685   //   $p_path : Path where the files and directories are to be extracted

   686   //   $p_remove_path : First part ('root' part) of the memorized path

   687   //                    (if any similar) to remove while extracting.

   688   // Options :

   689   //   PCLZIP_OPT_PATH :

   690   //   PCLZIP_OPT_ADD_PATH :

   691   //   PCLZIP_OPT_REMOVE_PATH :

   692   //   PCLZIP_OPT_REMOVE_ALL_PATH :

   693   //   PCLZIP_CB_PRE_EXTRACT :

   694   //   PCLZIP_CB_POST_EXTRACT :

   695   // Return Values :

   696   //   0 or a negative value on failure,

   697   //   The list of the extracted files, with a status of the action.

   698   //   (see PclZip::listContent() for list entry format)

   699   // --------------------------------------------------------------------------------

   700   function extract()

   701   {

   702     $v_result=1;

   703 

   704     // ----- Reset the error handler

   705     $this->privErrorReset();

   706 

   707     // ----- Check archive

   708     if (!$this->privCheckFormat()) {

   709       return(0);

   710     }

   711 

   712     // ----- Set default values

   713     $v_options = array();

   714 //    $v_path = "./";

   715     $v_path = '';

   716     $v_remove_path = "";

   717     $v_remove_all_path = false;

   718 

   719     // ----- Look for variable options arguments

   720     $v_size = func_num_args();

   721 

   722     // ----- Default values for option

   723     $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;

   724 

   725     // ----- Look for arguments

   726     if ($v_size > 0) {

   727       // ----- Get the arguments

   728       $v_arg_list = func_get_args();

   729 

   730       // ----- Look for first arg

   731       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

   732 

   733         // ----- Parse the options

   734         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

   735                                             array (PCLZIP_OPT_PATH => 'optional',

   736                                                    PCLZIP_OPT_REMOVE_PATH => 'optional',

   737                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',

   738                                                    PCLZIP_OPT_ADD_PATH => 'optional',

   739                                                    PCLZIP_CB_PRE_EXTRACT => 'optional',

   740                                                    PCLZIP_CB_POST_EXTRACT => 'optional',

   741                                                    PCLZIP_OPT_SET_CHMOD => 'optional',

   742                                                    PCLZIP_OPT_BY_NAME => 'optional',

   743                                                    PCLZIP_OPT_BY_EREG => 'optional',

   744                                                    PCLZIP_OPT_BY_PREG => 'optional',

   745                                                    PCLZIP_OPT_BY_INDEX => 'optional',

   746                                                    PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',

   747                                                    PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',

   748                                                    PCLZIP_OPT_REPLACE_NEWER => 'optional'

   749                                                    ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'

   750                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',

   751                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',

   752                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',

   753                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'

   754 												    ));

   755         if ($v_result != 1) {

   756           return 0;

   757         }

   758 

   759         // ----- Set the arguments

   760         if (isset($v_options[PCLZIP_OPT_PATH])) {

   761           $v_path = $v_options[PCLZIP_OPT_PATH];

   762         }

   763         if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {

   764           $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];

   765         }

   766         if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {

   767           $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];

   768         }

   769         if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {

   770           // ----- Check for '/' in last path char

   771           if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {

   772             $v_path .= '/';

   773           }

   774           $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];

   775         }

   776       }

   777 

   778       // ----- Look for 2 args

   779       // Here we need to support the first historic synopsis of the

   780       // method.

   781       else {

   782 

   783         // ----- Get the first argument

   784         $v_path = $v_arg_list[0];

   785 

   786         // ----- Look for the optional second argument

   787         if ($v_size == 2) {

   788           $v_remove_path = $v_arg_list[1];

   789         }

   790         else if ($v_size > 2) {

   791           // ----- Error log

   792           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");

   793 

   794           // ----- Return

   795           return 0;

   796         }

   797       }

   798     }

   799 

   800     // ----- Look for default option values

   801     $this->privOptionDefaultThreshold($v_options);

   802 

   803     // ----- Trace

   804 

   805     // ----- Call the extracting fct

   806     $p_list = array();

   807     $v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path,

   808 	                                     $v_remove_all_path, $v_options);

   809     if ($v_result < 1) {

   810       unset($p_list);

   811       return(0);

   812     }

   813 

   814     // ----- Return

   815     return $p_list;

   816   }

   817   // --------------------------------------------------------------------------------

   818 

   819 

   820   // --------------------------------------------------------------------------------

   821   // Function :

   822   //   extractByIndex($p_index, $p_path="./", $p_remove_path="")

   823   //   extractByIndex($p_index, [$p_option, $p_option_value, ...])

   824   // Description :

   825   //   This method supports two synopsis. The first one is historical.

   826   //   This method is doing a partial extract of the archive.

   827   //   The extracted files or folders are identified by their index in the

   828   //   archive (from 0 to n).

   829   //   Note that if the index identify a folder, only the folder entry is

   830   //   extracted, not all the files included in the archive.

   831   // Parameters :

   832   //   $p_index : A single index (integer) or a string of indexes of files to

   833   //              extract. The form of the string is "0,4-6,8-12" with only numbers

   834   //              and '-' for range or ',' to separate ranges. No spaces or ';'

   835   //              are allowed.

   836   //   $p_path : Path where the files and directories are to be extracted

   837   //   $p_remove_path : First part ('root' part) of the memorized path

   838   //                    (if any similar) to remove while extracting.

   839   // Options :

   840   //   PCLZIP_OPT_PATH :

   841   //   PCLZIP_OPT_ADD_PATH :

   842   //   PCLZIP_OPT_REMOVE_PATH :

   843   //   PCLZIP_OPT_REMOVE_ALL_PATH :

   844   //   PCLZIP_OPT_EXTRACT_AS_STRING : The files are extracted as strings and

   845   //     not as files.

   846   //     The resulting content is in a new field 'content' in the file

   847   //     structure.

   848   //     This option must be used alone (any other options are ignored).

   849   //   PCLZIP_CB_PRE_EXTRACT :

   850   //   PCLZIP_CB_POST_EXTRACT :

   851   // Return Values :

   852   //   0 on failure,

   853   //   The list of the extracted files, with a status of the action.

   854   //   (see PclZip::listContent() for list entry format)

   855   // --------------------------------------------------------------------------------

   856   //function extractByIndex($p_index, options...)

   857   function extractByIndex($p_index)

   858   {

   859     $v_result=1;

   860 

   861     // ----- Reset the error handler

   862     $this->privErrorReset();

   863 

   864     // ----- Check archive

   865     if (!$this->privCheckFormat()) {

   866       return(0);

   867     }

   868 

   869     // ----- Set default values

   870     $v_options = array();

   871 //    $v_path = "./";

   872     $v_path = '';

   873     $v_remove_path = "";

   874     $v_remove_all_path = false;

   875 

   876     // ----- Look for variable options arguments

   877     $v_size = func_num_args();

   878 

   879     // ----- Default values for option

   880     $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;

   881 

   882     // ----- Look for arguments

   883     if ($v_size > 1) {

   884       // ----- Get the arguments

   885       $v_arg_list = func_get_args();

   886 

   887       // ----- Remove form the options list the first argument

   888       array_shift($v_arg_list);

   889       $v_size--;

   890 

   891       // ----- Look for first arg

   892       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

   893 

   894         // ----- Parse the options

   895         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

   896                                             array (PCLZIP_OPT_PATH => 'optional',

   897                                                    PCLZIP_OPT_REMOVE_PATH => 'optional',

   898                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',

   899                                                    PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',

   900                                                    PCLZIP_OPT_ADD_PATH => 'optional',

   901                                                    PCLZIP_CB_PRE_EXTRACT => 'optional',

   902                                                    PCLZIP_CB_POST_EXTRACT => 'optional',

   903                                                    PCLZIP_OPT_SET_CHMOD => 'optional',

   904                                                    PCLZIP_OPT_REPLACE_NEWER => 'optional'

   905                                                    ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'

   906                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',

   907                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',

   908                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',

   909                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'

   910 												   ));

   911         if ($v_result != 1) {

   912           return 0;

   913         }

   914 

   915         // ----- Set the arguments

   916         if (isset($v_options[PCLZIP_OPT_PATH])) {

   917           $v_path = $v_options[PCLZIP_OPT_PATH];

   918         }

   919         if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {

   920           $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];

   921         }

   922         if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {

   923           $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];

   924         }

   925         if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {

   926           // ----- Check for '/' in last path char

   927           if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {

   928             $v_path .= '/';

   929           }

   930           $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];

   931         }

   932         if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {

   933           $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;

   934         }

   935         else {

   936         }

   937       }

   938 

   939       // ----- Look for 2 args

   940       // Here we need to support the first historic synopsis of the

   941       // method.

   942       else {

   943 

   944         // ----- Get the first argument

   945         $v_path = $v_arg_list[0];

   946 

   947         // ----- Look for the optional second argument

   948         if ($v_size == 2) {

   949           $v_remove_path = $v_arg_list[1];

   950         }

   951         else if ($v_size > 2) {

   952           // ----- Error log

   953           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");

   954 

   955           // ----- Return

   956           return 0;

   957         }

   958       }

   959     }

   960 

   961     // ----- Trace

   962 

   963     // ----- Trick

   964     // Here I want to reuse extractByRule(), so I need to parse the $p_index

   965     // with privParseOptions()

   966     $v_arg_trick = array (PCLZIP_OPT_BY_INDEX, $p_index);

   967     $v_options_trick = array();

   968     $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,

   969                                         array (PCLZIP_OPT_BY_INDEX => 'optional' ));

   970     if ($v_result != 1) {

   971         return 0;

   972     }

   973     $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];

   974 

   975     // ----- Look for default option values

   976     $this->privOptionDefaultThreshold($v_options);

   977 

   978     // ----- Call the extracting fct

   979     if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {

   980         return(0);

   981     }

   982 

   983     // ----- Return

   984     return $p_list;

   985   }

   986   // --------------------------------------------------------------------------------

   987 

   988   // --------------------------------------------------------------------------------

   989   // Function :

   990   //   delete([$p_option, $p_option_value, ...])

   991   // Description :

   992   //   This method removes files from the archive.

   993   //   If no parameters are given, then all the archive is emptied.

   994   // Parameters :

   995   //   None or optional arguments.

   996   // Options :

   997   //   PCLZIP_OPT_BY_INDEX :

   998   //   PCLZIP_OPT_BY_NAME :

   999   //   PCLZIP_OPT_BY_EREG :

  1000   //   PCLZIP_OPT_BY_PREG :

  1001   // Return Values :

  1002   //   0 on failure,

  1003   //   The list of the files which are still present in the archive.

  1004   //   (see PclZip::listContent() for list entry format)

  1005   // --------------------------------------------------------------------------------

  1006   function delete()

  1007   {

  1008     $v_result=1;

  1009 

  1010     // ----- Reset the error handler

  1011     $this->privErrorReset();

  1012 

  1013     // ----- Check archive

  1014     if (!$this->privCheckFormat()) {

  1015       return(0);

  1016     }

  1017 

  1018     // ----- Set default values

  1019     $v_options = array();

  1020 

  1021     // ----- Look for variable options arguments

  1022     $v_size = func_num_args();

  1023 

  1024     // ----- Look for arguments

  1025     if ($v_size > 0) {

  1026       // ----- Get the arguments

  1027       $v_arg_list = func_get_args();

  1028 

  1029       // ----- Parse the options

  1030       $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

  1031                                         array (PCLZIP_OPT_BY_NAME => 'optional',

  1032                                                PCLZIP_OPT_BY_EREG => 'optional',

  1033                                                PCLZIP_OPT_BY_PREG => 'optional',

  1034                                                PCLZIP_OPT_BY_INDEX => 'optional' ));

  1035       if ($v_result != 1) {

  1036           return 0;

  1037       }

  1038     }

  1039 

  1040     // ----- Magic quotes trick

  1041     $this->privDisableMagicQuotes();

  1042 

  1043     // ----- Call the delete fct

  1044     $v_list = array();

  1045     if (($v_result = $this->privDeleteByRule($v_list, $v_options)) != 1) {

  1046       $this->privSwapBackMagicQuotes();

  1047       unset($v_list);

  1048       return(0);

  1049     }

  1050 

  1051     // ----- Magic quotes trick

  1052     $this->privSwapBackMagicQuotes();

  1053 

  1054     // ----- Return

  1055     return $v_list;

  1056   }

  1057   // --------------------------------------------------------------------------------

  1058 

  1059   // --------------------------------------------------------------------------------

  1060   // Function : deleteByIndex()

  1061   // Description :

  1062   //   ***** Deprecated *****

  1063   //   delete(PCLZIP_OPT_BY_INDEX, $p_index) should be prefered.

  1064   // --------------------------------------------------------------------------------

  1065   function deleteByIndex($p_index)

  1066   {

  1067 

  1068     $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);

  1069 

  1070     // ----- Return

  1071     return $p_list;

  1072   }

  1073   // --------------------------------------------------------------------------------

  1074 

  1075   // --------------------------------------------------------------------------------

  1076   // Function : properties()

  1077   // Description :

  1078   //   This method gives the properties of the archive.

  1079   //   The properties are :

  1080   //     nb : Number of files in the archive

  1081   //     comment : Comment associated with the archive file

  1082   //     status : not_exist, ok

  1083   // Parameters :

  1084   //   None

  1085   // Return Values :

  1086   //   0 on failure,

  1087   //   An array with the archive properties.

  1088   // --------------------------------------------------------------------------------

  1089   function properties()

  1090   {

  1091 

  1092     // ----- Reset the error handler

  1093     $this->privErrorReset();

  1094 

  1095     // ----- Magic quotes trick

  1096     $this->privDisableMagicQuotes();

  1097 

  1098     // ----- Check archive

  1099     if (!$this->privCheckFormat()) {

  1100       $this->privSwapBackMagicQuotes();

  1101       return(0);

  1102     }

  1103 

  1104     // ----- Default properties

  1105     $v_prop = array();

  1106     $v_prop['comment'] = '';

  1107     $v_prop['nb'] = 0;

  1108     $v_prop['status'] = 'not_exist';

  1109 

  1110     // ----- Look if file exists

  1111     if (@is_file($this->zipname))

  1112     {

  1113       // ----- Open the zip file

  1114       if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)

  1115       {

  1116         $this->privSwapBackMagicQuotes();

  1117 

  1118         // ----- Error log

  1119         PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');

  1120 

  1121         // ----- Return

  1122         return 0;

  1123       }

  1124 

  1125       // ----- Read the central directory informations

  1126       $v_central_dir = array();

  1127       if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)

  1128       {

  1129         $this->privSwapBackMagicQuotes();

  1130         return 0;

  1131       }

  1132 

  1133       // ----- Close the zip file

  1134       $this->privCloseFd();

  1135 

  1136       // ----- Set the user attributes