Make WordPress Core

Changeset 11025


Ignore:
Timestamp:
04/20/2009 10:25:40 PM (15 years ago)
Author:
ryan
Message:

Update pclzip to 2.7. Props simek. fixes #9464

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/wp-admin/includes/class-pclzip.php

    r8645 r11025  
    11<?php
    2 /**
    3  * PhpConcept Library - Zip Module 2.5
    4  *
    5  * Presentation :
    6  *   PclZip is a PHP library that manage ZIP archives.
    7  *   So far tests show that archives generated by PclZip are readable by
    8  *   WinZip application and other tools.
    9  *
    10  * Warning :
    11  *   This library and the associated files are non commercial, non professional
    12  *   work.
    13  *   It should not have unexpected results. However if any damage is caused by
    14  *   this software the author can not be responsible.
    15  *   The use of this software is at the risk of the user.
    16  *
    17  * @package External
    18  * @subpackage PclZip
    19  *
    20  * @license License GNU/LGPL
    21  * @copyright March 2006 Vincent Blavet
    22  * @author Vincent Blavet
    23  * @link http://www.phpconcept.net
    24  * @version $Id: pclzip.lib.php,v 1.44 2006/03/08 21:23:59 vblavet Exp $
    25  */
    26 
    27 /**
    28  * The read block size for reading zip files.
    29  *
    30  * @since 2.5
    31  */
    32 define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
    33 
    34 /**
    35  * File list separator
    36  *
    37  * In version 1.x of PclZip, the separator for file list is a space(which is not
    38  * a very smart choice, specifically for windows paths !). A better separator
    39  * should be a comma (,). This constant gives you the abilty to change that.
    40  *
    41  * However notice that changing this value, may have impact on existing scripts,
    42  * using space separated filenames. Recommanded values for compatibility with
    43  * older versions :
    44  * <code>define( 'PCLZIP_SEPARATOR', ' ' );</code>
    45  * Recommanded values for smart separation of filenames.
    46  */
    47 define( 'PCLZIP_SEPARATOR', ',' );
    48 
    49 /**
    50  * Error configuration
    51  *
    52  * 0 : PclZip Class integrated error handling
    53  * 1 : PclError external library error handling. By enabling this you must
    54  *     ensure that you have included PclError library.
    55  * [2,...] : reserved for future use
    56  */
    57 define( 'PCLZIP_ERROR_EXTERNAL', 0 );
     2// --------------------------------------------------------------------------------
     3// PhpConcept Library - Zip Module 2.7
     4// --------------------------------------------------------------------------------
     5// License GNU/LGPL - Vincent Blavet - March 2006
     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.50 2009/03/24 17:13:52 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  }
    5855
    5956  // ----- Optional static temporary directory
    60   //       By default temporary files are generated in the script current
    61   //       path.
    62   //       If defined :
    63   //       - MUST BE terminated by a '/'.
    64   //       - MUST be a valid, already created directory
    65   //       Samples :
     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 :
    6663  // define( 'PCLZIP_TEMPORARY_DIR', '/temp/' );
    6764  // define( 'PCLZIP_TEMPORARY_DIR', 'C:/Temp/' );
    68   define( 'PCLZIP_TEMPORARY_DIR', '' );
     65  if (!defined('PCLZIP_TEMPORARY_DIR')) {
     66    define( 'PCLZIP_TEMPORARY_DIR', '' );
     67  }
    6968
    7069// --------------------------------------------------------------------------------
     
    7372
    7473  // ----- Global variables
    75   $g_pclzip_version = "2.5";
     74  $g_pclzip_version = "2.7";
    7675
    7776  // ----- Error codes
     
    136135  //define( 'PCLZIP_OPT_CRYPT', 77018 );
    137136  define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );
    138 
     137  define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 );
     138  define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 );
     139  define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 );
     140 
    139141  // ----- File description attributes
    140142  define( 'PCLZIP_ATT_FILE_NAME', 79001 );
    141143  define( 'PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002 );
    142144  define( 'PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003 );
     145  define( 'PCLZIP_ATT_FILE_MTIME', 79004 );
     146  define( 'PCLZIP_ATT_FILE_CONTENT', 79005 );
     147  define( 'PCLZIP_ATT_FILE_COMMENT', 79006 );
    143148
    144149  // ----- Call backs values
     
    147152  define( 'PCLZIP_CB_PRE_ADD', 78003 );
    148153  define( 'PCLZIP_CB_POST_ADD', 78004 );
    149   /* For future use
     154  /* For futur use
    150155  define( 'PCLZIP_CB_PRE_LIST', 78005 );
    151156  define( 'PCLZIP_CB_POST_LIST', 78006 );
     
    170175  class PclZip
    171176  {
    172     // ----- Filename of the zip file
    173     var $zipname = '';
    174 
    175     // ----- File descriptor of the zip file
    176     var $zip_fd = 0;
    177 
    178     // ----- Internal error handling
    179     var $error_code = 1;
    180     var $error_string = '';
    181 
    182     // ----- Current status of the magic_quotes_runtime
    183     // This value store the php configuration for magic_quotes
    184     // The class can then disable the magic_quotes and reset it after
    185     var $magic_quotes_status;
     177    // ----- Filename of the zip file
     178    var $zipname = '';
     179
     180    // ----- File descriptor of the zip file
     181    var $zip_fd = 0;
     182
     183    // ----- Internal error handling
     184    var $error_code = 1;
     185    var $error_string = '';
     186   
     187    // ----- Current status of the magic_quotes_runtime
     188    // This value store the php configuration for magic_quotes
     189    // The class can then disable the magic_quotes and reset it after
     190    var $magic_quotes_status;
    186191
    187192  // --------------------------------------------------------------------------------
     
    195200  function PclZip($p_zipname)
    196201  {
    197     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::PclZip', "zipname=$p_zipname");
    198 
    199     // ----- Tests the zlib
    200     if (!function_exists('gzopen'))
    201     {
    202       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 1, "zlib extension seems to be missing");
    203       die('Abort '.basename(__FILE__).' : Missing zlib extensions');
    204     }
    205 
    206     // ----- Set the attributes
    207     $this->zipname = $p_zipname;
    208     $this->zip_fd = 0;
    209     $this->magic_quotes_status = -1;
    210 
    211     // ----- Return
    212     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 1);
    213     return;
     202    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::PclZip', "zipname=$p_zipname");
     203
     204    // ----- Tests the zlib
     205    if (!function_exists('gzopen'))
     206    {
     207      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 1, "zlib extension seems to be missing");
     208      die('Abort '.basename(__FILE__).' : Missing zlib extensions');
     209    }
     210
     211    // ----- Set the attributes
     212    $this->zipname = $p_zipname;
     213    $this->zip_fd = 0;
     214    $this->magic_quotes_status = -1;
     215
     216    // ----- Return
     217    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 1);
     218    return;
    214219  }
    215220  // --------------------------------------------------------------------------------
     
    231236  // Parameters :
    232237  //   $p_filelist : An array containing file or directory names, or
    233   //                a string containing one filename or one directory name, or
    234   //                a string containing a list of filenames and/or directory
    235   //                names separated by spaces.
     238  //                a string containing one filename or one directory name, or
     239  //                a string containing a list of filenames and/or directory
     240  //                names separated by spaces.
    236241  //   $p_add_dir : A path to add before the real path of the archived file,
    237   //                in order to have it memorized in the archive.
     242  //                in order to have it memorized in the archive.
    238243  //   $p_remove_dir : A path to remove from the real path of the file to archive,
    239   //                   in order to have a shorter path memorized in the archive.
    240   //                   When $p_add_dir and $p_remove_dir are set, $p_remove_dir
    241   //                   is removed first, before $p_add_dir is added.
     244  //                   in order to have a shorter path memorized in the archive.
     245  //                   When $p_add_dir and $p_remove_dir are set, $p_remove_dir
     246  //                   is removed first, before $p_add_dir is added.
    242247  // Options :
    243248  //   PCLZIP_OPT_ADD_PATH :
     
    254259  function create($p_filelist)
    255260  {
    256     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::create', "filelist='$p_filelist', ...");
    257     $v_result=1;
    258 
    259     // ----- Reset the error handler
    260     $this->privErrorReset();
    261 
    262     // ----- Set default values
    263     $v_options = array();
    264     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
    265 
    266     // ----- Look for variable options arguments
    267     $v_size = func_num_args();
    268     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    269 
    270     // ----- Look for arguments
    271     if ($v_size > 1) {
    272       // ----- Get the arguments
    273       $v_arg_list = func_get_args();
    274 
    275       // ----- Remove from the options list the first argument
    276       array_shift($v_arg_list);
    277       $v_size--;
    278 
    279       // ----- Look for first arg
    280       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    281         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options detected");
    282 
    283         // ----- Parse the options
    284         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    285                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',
    286                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
    287                                                    PCLZIP_OPT_ADD_PATH => 'optional',
    288                                                    PCLZIP_CB_PRE_ADD => 'optional',
    289                                                    PCLZIP_CB_POST_ADD => 'optional',
    290                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',
    291                                                    PCLZIP_OPT_COMMENT => 'optional'
    292                                                    //, PCLZIP_OPT_CRYPT => 'optional'
    293                                              ));
    294         if ($v_result != 1) {
    295           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    296           return 0;
    297         }
    298       }
    299 
    300       // ----- Look for 2 args
    301       // Here we need to support the first historic synopsis of the
    302       // method.
    303       else {
    304         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    305 
    306         // ----- Get the first argument
    307         $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];
    308 
    309         // ----- Look for the optional second argument
    310         if ($v_size == 2) {
    311           $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
    312         }
    313         else if ($v_size > 2) {
    314           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
    315                                "Invalid number / type of arguments");
    316           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    317           return 0;
    318         }
    319       }
    320     }
    321 
    322     // ----- Init
    323     $v_string_list = array();
    324     $v_att_list = array();
    325     $v_filedescr_list = array();
    326     $p_result_list = array();
    327 
    328     // ----- Look if the $p_filelist is really an array
    329     if (is_array($p_filelist)) {
    330 
    331       // ----- Look if the first element is also an array
    332       //       This will mean that this is a file description entry
    333       if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
    334         $v_att_list = $p_filelist;
    335       }
    336 
    337       // ----- The list is a list of string names
    338       else {
    339         $v_string_list = $p_filelist;
    340       }
    341     }
    342 
    343     // ----- Look if the $p_filelist is a string
    344     else if (is_string($p_filelist)) {
    345       // ----- Create a list from the string
    346       $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
    347     }
    348 
    349     // ----- Invalid variable type for $p_filelist
    350     else {
    351       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
    352       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    353       return 0;
    354     }
    355 
    356     // ----- Reformat the string list
    357     if (sizeof($v_string_list) != 0) {
    358       foreach ($v_string_list as $v_string) {
    359         if ($v_string != '') {
    360           $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
    361         }
    362         else {
    363           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Ignore an empty filename");
    364         }
    365       }
    366     }
    367 
    368     // ----- For each file in the list check the attributes
    369     $v_supported_attributes
    370     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
    371              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
    372              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
     261    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::create', "filelist='$p_filelist', ...");
     262    $v_result=1;
     263
     264    // ----- Reset the error handler
     265    $this->privErrorReset();
     266
     267    // ----- Set default values
     268    $v_options = array();
     269    $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
     270
     271    // ----- Look for variable options arguments
     272    $v_size = func_num_args();
     273    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
     274
     275    // ----- Look for arguments
     276    if ($v_size > 1) {
     277      // ----- Get the arguments
     278      $v_arg_list = func_get_args();
     279
     280      // ----- Remove from the options list the first argument
     281      array_shift($v_arg_list);
     282      $v_size--;
     283
     284      // ----- Look for first arg
     285      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
     286        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options detected");
     287
     288        // ----- Parse the options
     289        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
     290                                            array (PCLZIP_OPT_REMOVE_PATH => 'optional',
     291                                                   PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     292                                                   PCLZIP_OPT_ADD_PATH => 'optional',
     293                                                   PCLZIP_CB_PRE_ADD => 'optional',
     294                                                   PCLZIP_CB_POST_ADD => 'optional',
     295                                                   PCLZIP_OPT_NO_COMPRESSION => 'optional',
     296                                                   PCLZIP_OPT_COMMENT => 'optional',
     297                                                   PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD => 'optional',
     298                                                   PCLZIP_OPT_ADD_TEMP_FILE_ON => 'optional',
     299                                                   PCLZIP_OPT_ADD_TEMP_FILE_OFF => 'optional'
     300                                                   //, PCLZIP_OPT_CRYPT => 'optional'
     301                                             ));
     302        if ($v_result != 1) {
     303          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     304          return 0;
     305        }
     306      }
     307
     308      // ----- Look for 2 args
     309      // Here we need to support the first historic synopsis of the
     310      // method.
     311      else {
     312        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
     313
     314        // ----- Get the first argument
     315        $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];
     316
     317        // ----- Look for the optional second argument
     318        if ($v_size == 2) {
     319          $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
     320        }
     321        else if ($v_size > 2) {
     322          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     323                               "Invalid number / type of arguments");
     324          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     325          return 0;
     326        }
     327      }
     328    }
     329   
     330    // ----- Look for default option values
     331    if (!isset($v_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
     332      $this->privOptionDefaultThreshold($v_options);
     333    }
     334
     335    // ----- Init
     336    $v_string_list = array();
     337    $v_att_list = array();
     338    $v_filedescr_list = array();
     339    $p_result_list = array();
     340   
     341    // ----- Look if the $p_filelist is really an array
     342    if (is_array($p_filelist)) {
     343   
     344      // ----- Look if the first element is also an array
     345      //       This will mean that this is a file description entry
     346      if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
     347        $v_att_list = $p_filelist;
     348      }
     349     
     350      // ----- The list is a list of string names
     351      else {
     352        $v_string_list = $p_filelist;
     353      }
     354    }
     355
     356    // ----- Look if the $p_filelist is a string
     357    else if (is_string($p_filelist)) {
     358      // ----- Create a list from the string
     359      $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
     360    }
     361
     362    // ----- Invalid variable type for $p_filelist
     363    else {
     364      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
     365      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     366      return 0;
     367    }
     368   
     369    // ----- Reformat the string list
     370    if (sizeof($v_string_list) != 0) {
     371      foreach ($v_string_list as $v_string) {
     372        if ($v_string != '') {
     373          $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
     374        }
     375        else {
     376          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Ignore an empty filename");
     377        }
     378      }
     379    }
     380   
     381    // ----- For each file in the list check the attributes
     382    $v_supported_attributes
     383    = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
     384             ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
     385             ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
     386             ,PCLZIP_ATT_FILE_MTIME => 'optional'
     387             ,PCLZIP_ATT_FILE_CONTENT => 'optional'
     388             ,PCLZIP_ATT_FILE_COMMENT => 'optional'
    373389                        );
    374     foreach ($v_att_list as $v_entry) {
    375       $v_result = $this->privFileDescrParseAtt($v_entry,
    376                                                $v_filedescr_list[],
    377                                                $v_options,
    378                                                $v_supported_attributes);
    379       if ($v_result != 1) {
    380         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    381         return 0;
    382       }
    383     }
    384 
    385     // ----- Expand the filelist (expand directories)
    386     $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
    387     if ($v_result != 1) {
    388       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    389       return 0;
    390     }
    391 
    392     // ----- Call the create fct
    393     $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);
    394     if ($v_result != 1) {
    395       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    396       return 0;
    397     }
    398 
    399     // ----- Return
    400     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_result_list);
    401     return $p_result_list;
     390    foreach ($v_att_list as $v_entry) {
     391      $v_result = $this->privFileDescrParseAtt($v_entry,
     392                                               $v_filedescr_list[],
     393                                               $v_options,
     394                                               $v_supported_attributes);
     395      if ($v_result != 1) {
     396        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     397        return 0;
     398      }
     399    }
     400
     401    // ----- Expand the filelist (expand directories)
     402    $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
     403    if ($v_result != 1) {
     404      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     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      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     412      return 0;
     413    }
     414
     415    // ----- Return
     416    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_result_list);
     417    return $p_result_list;
    402418  }
    403419  // --------------------------------------------------------------------------------
     
    415431  // Parameters :
    416432  //   $p_filelist : An array containing file or directory names, or
    417   //                a string containing one filename or one directory name, or
    418   //                a string containing a list of filenames and/or directory
    419   //                names separated by spaces.
     433  //                a string containing one filename or one directory name, or
     434  //                a string containing a list of filenames and/or directory
     435  //                names separated by spaces.
    420436  //   $p_add_dir : A path to add before the real path of the archived file,
    421   //                in order to have it memorized in the archive.
     437  //                in order to have it memorized in the archive.
    422438  //   $p_remove_dir : A path to remove from the real path of the file to archive,
    423   //                   in order to have a shorter path memorized in the archive.
    424   //                   When $p_add_dir and $p_remove_dir are set, $p_remove_dir
    425   //                   is removed first, before $p_add_dir is added.
     439  //                   in order to have a shorter path memorized in the archive.
     440  //                   When $p_add_dir and $p_remove_dir are set, $p_remove_dir
     441  //                   is removed first, before $p_add_dir is added.
    426442  // Options :
    427443  //   PCLZIP_OPT_ADD_PATH :
     
    440456  function add($p_filelist)
    441457  {
    442     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::add', "filelist='$p_filelist', ...");
    443     $v_result=1;
    444 
    445     // ----- Reset the error handler
    446     $this->privErrorReset();
    447 
    448     // ----- Set default values
    449     $v_options = array();
    450     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
    451 
    452     // ----- Look for variable options arguments
    453     $v_size = func_num_args();
    454     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    455 
    456     // ----- Look for arguments
    457     if ($v_size > 1) {
    458       // ----- Get the arguments
    459       $v_arg_list = func_get_args();
    460 
    461       // ----- Remove form the options list the first argument
    462       array_shift($v_arg_list);
    463       $v_size--;
    464 
    465       // ----- Look for first arg
    466       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    467         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options detected");
    468 
    469         // ----- Parse the options
    470         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    471                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',
    472                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
    473                                                    PCLZIP_OPT_ADD_PATH => 'optional',
    474                                                    PCLZIP_CB_PRE_ADD => 'optional',
    475                                                    PCLZIP_CB_POST_ADD => 'optional',
    476                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',
    477                                                    PCLZIP_OPT_COMMENT => 'optional',
    478                                                    PCLZIP_OPT_ADD_COMMENT => 'optional',
    479                                                    PCLZIP_OPT_PREPEND_COMMENT => 'optional'
    480                                                    //, PCLZIP_OPT_CRYPT => 'optional'
     458    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::add', "filelist='$p_filelist', ...");
     459    $v_result=1;
     460
     461    // ----- Reset the error handler
     462    $this->privErrorReset();
     463
     464    // ----- Set default values
     465    $v_options = array();
     466    $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
     467
     468    // ----- Look for variable options arguments
     469    $v_size = func_num_args();
     470    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
     471
     472    // ----- Look for arguments
     473    if ($v_size > 1) {
     474      // ----- Get the arguments
     475      $v_arg_list = func_get_args();
     476
     477      // ----- Remove form the options list the first argument
     478      array_shift($v_arg_list);
     479      $v_size--;
     480
     481      // ----- Look for first arg
     482      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
     483        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options detected");
     484
     485        // ----- Parse the options
     486        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
     487                                            array (PCLZIP_OPT_REMOVE_PATH => 'optional',
     488                                                   PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     489                                                   PCLZIP_OPT_ADD_PATH => 'optional',
     490                                                   PCLZIP_CB_PRE_ADD => 'optional',
     491                                                   PCLZIP_CB_POST_ADD => 'optional',
     492                                                   PCLZIP_OPT_NO_COMPRESSION => 'optional',
     493                                                   PCLZIP_OPT_COMMENT => 'optional',
     494                                                   PCLZIP_OPT_ADD_COMMENT => 'optional',
     495                                                   PCLZIP_OPT_PREPEND_COMMENT => 'optional',
     496                                                   PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD => 'optional',
     497                                                   PCLZIP_OPT_ADD_TEMP_FILE_ON => 'optional',
     498                                                   PCLZIP_OPT_ADD_TEMP_FILE_OFF => 'optional'
     499                                                   //, PCLZIP_OPT_CRYPT => 'optional'
    481500                                                   ));
    482         if ($v_result != 1) {
    483           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    484           return 0;
    485         }
    486       }
    487 
    488       // ----- Look for 2 args
    489       // Here we need to support the first historic synopsis of the
    490       // method.
    491       else {
    492         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    493 
    494         // ----- Get the first argument
    495         $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];
    496 
    497         // ----- Look for the optional second argument
    498         if ($v_size == 2) {
    499           $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
    500         }
    501         else if ($v_size > 2) {
    502           // ----- Error log
    503           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
    504 
    505           // ----- Return
    506           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    507           return 0;
    508         }
    509       }
    510     }
    511 
    512     // ----- Init
    513     $v_string_list = array();
    514     $v_att_list = array();
    515     $v_filedescr_list = array();
    516     $p_result_list = array();
    517 
    518     // ----- Look if the $p_filelist is really an array
    519     if (is_array($p_filelist)) {
    520 
    521       // ----- Look if the first element is also an array
    522       //       This will mean that this is a file description entry
    523       if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
    524         $v_att_list = $p_filelist;
    525       }
    526 
    527       // ----- The list is a list of string names
    528       else {
    529         $v_string_list = $p_filelist;
    530       }
    531     }
    532 
    533     // ----- Look if the $p_filelist is a string
    534     else if (is_string($p_filelist)) {
    535       // ----- Create a list from the string
    536       $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
    537     }
    538 
    539     // ----- Invalid variable type for $p_filelist
    540     else {
    541       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
    542       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    543       return 0;
    544     }
    545 
    546     // ----- Reformat the string list
    547     if (sizeof($v_string_list) != 0) {
    548       foreach ($v_string_list as $v_string) {
    549         $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
    550       }
    551     }
    552 
    553     // ----- For each file in the list check the attributes
    554     $v_supported_attributes
    555     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
    556              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
    557              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
     501        if ($v_result != 1) {
     502          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     503          return 0;
     504        }
     505      }
     506
     507      // ----- Look for 2 args
     508      // Here we need to support the first historic synopsis of the
     509      // method.
     510      else {
     511        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
     512
     513        // ----- Get the first argument
     514        $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];
     515
     516        // ----- Look for the optional second argument
     517        if ($v_size == 2) {
     518          $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
     519        }
     520        else if ($v_size > 2) {
     521          // ----- Error log
     522          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
     523
     524          // ----- Return
     525          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     526          return 0;
     527        }
     528      }
     529    }
     530
     531    // ----- Look for default option values
     532    if (!isset($v_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
     533      $this->privOptionDefaultThreshold($v_options);
     534    }
     535
     536    // ----- Init
     537    $v_string_list = array();
     538    $v_att_list = array();
     539    $v_filedescr_list = array();
     540    $p_result_list = array();
     541   
     542    // ----- Look if the $p_filelist is really an array
     543    if (is_array($p_filelist)) {
     544   
     545      // ----- Look if the first element is also an array
     546      //       This will mean that this is a file description entry
     547      if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
     548        $v_att_list = $p_filelist;
     549      }
     550     
     551      // ----- The list is a list of string names
     552      else {
     553        $v_string_list = $p_filelist;
     554      }
     555    }
     556
     557    // ----- Look if the $p_filelist is a string
     558    else if (is_string($p_filelist)) {
     559      // ----- Create a list from the string
     560      $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
     561    }
     562
     563    // ----- Invalid variable type for $p_filelist
     564    else {
     565      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
     566      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     567      return 0;
     568    }
     569   
     570    // ----- Reformat the string list
     571    if (sizeof($v_string_list) != 0) {
     572      foreach ($v_string_list as $v_string) {
     573        $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
     574      }
     575    }
     576   
     577    // ----- For each file in the list check the attributes
     578    $v_supported_attributes
     579    = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
     580             ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
     581             ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
     582             ,PCLZIP_ATT_FILE_MTIME => 'optional'
     583             ,PCLZIP_ATT_FILE_CONTENT => 'optional'
     584             ,PCLZIP_ATT_FILE_COMMENT => 'optional'
    558585                        );
    559     foreach ($v_att_list as $v_entry) {
    560       $v_result = $this->privFileDescrParseAtt($v_entry,
    561                                                $v_filedescr_list[],
    562                                                $v_options,
    563                                                $v_supported_attributes);
    564       if ($v_result != 1) {
    565         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    566         return 0;
    567       }
    568     }
    569 
    570     // ----- Expand the filelist (expand directories)
    571     $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
    572     if ($v_result != 1) {
    573       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    574       return 0;
    575     }
    576 
    577     // ----- Call the create fct
    578     $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);
    579     if ($v_result != 1) {
    580       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    581       return 0;
    582     }
    583 
    584     // ----- Return
    585     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_result_list);
    586     return $p_result_list;
     586    foreach ($v_att_list as $v_entry) {
     587      $v_result = $this->privFileDescrParseAtt($v_entry,
     588                                               $v_filedescr_list[],
     589                                               $v_options,
     590                                               $v_supported_attributes);
     591      if ($v_result != 1) {
     592        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     593        return 0;
     594      }
     595    }
     596
     597    // ----- Expand the filelist (expand directories)
     598    $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
     599    if ($v_result != 1) {
     600      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     601      return 0;
     602    }
     603
     604    // ----- Call the create fct
     605    $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);
     606    if ($v_result != 1) {
     607      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     608      return 0;
     609    }
     610
     611    // ----- Return
     612    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_result_list);
     613    return $p_result_list;
    587614  }
    588615  // --------------------------------------------------------------------------------
     
    594621  //   properties.
    595622  //   The properties of each entries in the list are (used also in other functions) :
    596   //    filename : Name of the file. For a create or add action it is the filename
    597   //                given by the user. For an extract function it is the filename
    598   //                of the extracted file.
    599   //    stored_filename : Name of the file / directory stored in the archive.
    600   //    size : Size of the stored file.
    601   //    compressed_size : Size of the file's data compressed in the archive
    602   //                       (without the headers overhead)
    603   //    mtime : Last known modification date of the file (UNIX timestamp)
    604   //    comment : Comment associated with the file
    605   //    folder : true | false
    606   //    index : index of the file in the archive
    607   //    status : status of the action (depending of the action) :
    608   //              Values are :
    609   //                ok : OK !
    610   //                filtered : the file / dir is not extracted (filtered by user)
    611   //                already_a_directory : the file can not be extracted because a
    612   //                                      directory with the same name already exists
    613   //                write_protected : the file can not be extracted because a file
    614   //                                  with the same name already exists and is
    615   //                                  write protected
    616   //                newer_exist : the file was not extracted because a newer file exists
    617   //                path_creation_fail : the file is not extracted because the folder
    618   //                                     does not exists and can not be created
    619   //                write_error : the file was not extracted because there was a
    620   //                              error while writing the file
    621   //                read_error : the file was not extracted because there was a error
    622   //                            while reading the file
    623   //                invalid_header : the file was not extracted because of an archive
    624   //                                format error (bad file header)
     623  //    filename : Name of the file. For a create or add action it is the filename
     624  //                given by the user. For an extract function it is the filename
     625  //                of the extracted file.
     626  //    stored_filename : Name of the file / directory stored in the archive.
     627  //    size : Size of the stored file.
     628  //    compressed_size : Size of the file's data compressed in the archive
     629  //                       (without the headers overhead)
     630  //    mtime : Last known modification date of the file (UNIX timestamp)
     631  //    comment : Comment associated with the file
     632  //    folder : true | false
     633  //    index : index of the file in the archive
     634  //    status : status of the action (depending of the action) :
     635  //              Values are :
     636  //                ok : OK !
     637  //                filtered : the file / dir is not extracted (filtered by user)
     638  //                already_a_directory : the file can not be extracted because a
     639  //                                      directory with the same name already exists
     640  //                write_protected : the file can not be extracted because a file
     641  //                                  with the same name already exists and is
     642  //                                  write protected
     643  //                newer_exist : the file was not extracted because a newer file exists
     644  //                path_creation_fail : the file is not extracted because the folder
     645  //                                     does not exist and can not be created
     646  //                write_error : the file was not extracted because there was a
     647  //                              error while writing the file
     648  //                read_error : the file was not extracted because there was a error
     649  //                            while reading the file
     650  //                invalid_header : the file was not extracted because of an archive
     651  //                                format error (bad file header)
    625652  //   Note that each time a method can continue operating when there
    626653  //   is an action error on a file, the error is only logged in the file status.
     
    631658  function listContent()
    632659  {
    633     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::listContent', "");
    634     $v_result=1;
    635 
    636     // ----- Reset the error handler
    637     $this->privErrorReset();
    638 
    639     // ----- Check archive
    640     if (!$this->privCheckFormat()) {
    641       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    642       return(0);
    643     }
    644 
    645     // ----- Call the extracting fct
    646     $p_list = array();
    647     if (($v_result = $this->privList($p_list)) != 1)
    648     {
    649       unset($p_list);
    650       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    651       return(0);
    652     }
    653 
    654     // ----- Return
    655     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    656     return $p_list;
     660    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::listContent', "");
     661    $v_result=1;
     662
     663    // ----- Reset the error handler
     664    $this->privErrorReset();
     665
     666    // ----- Check archive
     667    if (!$this->privCheckFormat()) {
     668      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     669      return(0);
     670    }
     671
     672    // ----- Call the extracting fct
     673    $p_list = array();
     674    if (($v_result = $this->privList($p_list)) != 1)
     675    {
     676      unset($p_list);
     677      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
     678      return(0);
     679    }
     680
     681    // ----- Return
     682    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
     683    return $p_list;
    657684  }
    658685  // --------------------------------------------------------------------------------
     
    677704  //   $p_path : Path where the files and directories are to be extracted
    678705  //   $p_remove_path : First part ('root' part) of the memorized path
    679   //                    (if any similar) to remove while extracting.
     706  //                    (if any similar) to remove while extracting.
    680707  // Options :
    681708  //   PCLZIP_OPT_PATH :
     
    692719  function extract()
    693720  {
    694     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::extract", "");
    695     $v_result=1;
    696 
    697     // ----- Reset the error handler
    698     $this->privErrorReset();
    699 
    700     // ----- Check archive
    701     if (!$this->privCheckFormat()) {
    702       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    703       return(0);
    704     }
    705 
    706     // ----- Set default values
    707     $v_options = array();
    708 //    $v_path = "./";
    709     $v_path = '';
    710     $v_remove_path = "";
    711     $v_remove_all_path = false;
    712 
    713     // ----- Look for variable options arguments
    714     $v_size = func_num_args();
    715     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    716 
    717     // ----- Default values for option
    718     $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
    719 
    720     // ----- Look for arguments
    721     if ($v_size > 0) {
    722       // ----- Get the arguments
    723       $v_arg_list = func_get_args();
    724 
    725       // ----- Look for first arg
    726       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    727         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options");
    728 
    729         // ----- Parse the options
    730         $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    731                                             array (PCLZIP_OPT_PATH => 'optional',
    732                                                    PCLZIP_OPT_REMOVE_PATH => 'optional',
    733                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
    734                                                    PCLZIP_OPT_ADD_PATH => 'optional',
    735                                                    PCLZIP_CB_PRE_EXTRACT => 'optional',
    736                                                    PCLZIP_CB_POST_EXTRACT => 'optional',
    737                                                    PCLZIP_OPT_SET_CHMOD => 'optional',
    738                                                    PCLZIP_OPT_BY_NAME => 'optional',
    739                                                    PCLZIP_OPT_BY_EREG => 'optional',
    740                                                    PCLZIP_OPT_BY_PREG => 'optional',
    741                                                    PCLZIP_OPT_BY_INDEX => 'optional',
    742                                                    PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
    743                                                    PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',
    744                                                    PCLZIP_OPT_REPLACE_NEWER => 'optional'
    745                                                    ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
    746                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional'
    747                                                     ));
    748         if ($v_result != 1) {
    749           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    750           return 0;
    751         }
    752 
    753         // ----- Set the arguments
    754         if (isset($v_options[PCLZIP_OPT_PATH])) {
    755           $v_path = $v_options[PCLZIP_OPT_PATH];
    756         }
    757         if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
    758           $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
    759         }
    760         if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
    761           $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
    762         }
    763         if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
    764           // ----- Check for '/' in last path char
    765           if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
    766             $v_path .= '/';
    767           }
    768           $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
    769         }
    770       }
    771 
    772       // ----- Look for 2 args
    773       // Here we need to support the first historic synopsis of the
    774       // method.
    775       else {
    776         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    777 
    778         // ----- Get the first argument
    779         $v_path = $v_arg_list[0];
    780 
    781         // ----- Look for the optional second argument
    782         if ($v_size == 2) {
    783           $v_remove_path = $v_arg_list[1];
    784         }
    785         else if ($v_size > 2) {
    786           // ----- Error log
    787           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
    788 
    789           // ----- Return
    790           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    791           return 0;
    792         }
    793       }
    794     }
    795 
    796     // ----- Trace
    797     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "path='$v_path', remove_path='$v_remove_path', remove_all_path='".($v_remove_path?'true':'false')."'");
    798 
    799     // ----- Call the extracting fct
    800     $p_list = array();
    801     $v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path,
    802                                         $v_remove_all_path, $v_options);
    803     if ($v_result < 1) {
    804       unset($p_list);
    805       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    806       return(0);
    807     }
    808 
    809     // ----- Return
    810     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    811     return $p_list;
     721    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::extract", "");
     722    $v_result=1;
     723
     724    // ----- Reset the error handler
     725    $this->privErrorReset();
     726
     727    // ----- Check archive
     728    if (!$this->privCheckFormat()) {
     729      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     730      return(0);
     731    }
     732
     733    // ----- Set default values
     734    $v_options = array();
     735//  $v_path = "./";
     736    $v_path = '';
     737    $v_remove_path = "";
     738    $v_remove_all_path = false;
     739
     740    // ----- Look for variable options arguments
     741    $v_size = func_num_args();
     742    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
     743
     744    // ----- Default values for option
     745    $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
     746
     747    // ----- Look for arguments
     748    if ($v_size > 0) {
     749      // ----- Get the arguments
     750      $v_arg_list = func_get_args();
     751
     752      // ----- Look for first arg
     753      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
     754        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options");
     755
     756        // ----- Parse the options
     757        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
     758                                            array (PCLZIP_OPT_PATH => 'optional',
     759                                                   PCLZIP_OPT_REMOVE_PATH => 'optional',
     760                                                   PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     761                                                   PCLZIP_OPT_ADD_PATH => 'optional',
     762                                                   PCLZIP_CB_PRE_EXTRACT => 'optional',
     763                                                   PCLZIP_CB_POST_EXTRACT => 'optional',
     764                                                   PCLZIP_OPT_SET_CHMOD => 'optional',
     765                                                   PCLZIP_OPT_BY_NAME => 'optional',
     766                                                   PCLZIP_OPT_BY_EREG => 'optional',
     767                                                   PCLZIP_OPT_BY_PREG => 'optional',
     768                                                   PCLZIP_OPT_BY_INDEX => 'optional',
     769                                                   PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
     770                                                   PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',
     771                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'
     772                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
     773                                                   ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional'
     774                                                    ));
     775        if ($v_result != 1) {
     776          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     777          return 0;
     778        }
     779
     780        // ----- Set the arguments
     781        if (isset($v_options[PCLZIP_OPT_PATH])) {
     782          $v_path = $v_options[PCLZIP_OPT_PATH];
     783        }
     784        if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
     785          $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
     786        }
     787        if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
     788          $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
     789        }
     790        if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
     791          // ----- Check for '/' in last path char
     792          if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
     793            $v_path .= '/';
     794          }
     795          $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
     796        }
     797      }
     798
     799      // ----- Look for 2 args
     800      // Here we need to support the first historic synopsis of the
     801      // method.
     802      else {
     803        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
     804
     805        // ----- Get the first argument
     806        $v_path = $v_arg_list[0];
     807
     808        // ----- Look for the optional second argument
     809        if ($v_size == 2) {
     810          $v_remove_path = $v_arg_list[1];
     811        }
     812        else if ($v_size > 2) {
     813          // ----- Error log
     814          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
     815
     816          // ----- Return
     817          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
     818          return 0;
     819        }
     820      }
     821    }
     822
     823    // ----- Trace
     824    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "path='$v_path', remove_path='$v_remove_path', remove_all_path='".($v_remove_path?'true':'false')."'");
     825
     826    // ----- Call the extracting fct
     827    $p_list = array();
     828    $v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path,
     829                                        $v_remove_all_path, $v_options);
     830    if ($v_result < 1) {
     831      unset($p_list);
     832      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
     833      return(0);
     834    }
     835
     836    // ----- Return
     837    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
     838    return $p_list;
    812839  }
    813840  // --------------------------------------------------------------------------------
     
    827854  // Parameters :
    828855  //   $p_index : A single index (integer) or a string of indexes of files to
    829   //              extract. The form of the string is "0,4-6,8-12" with only numbers
    830   //              and '-' for range or ',' to separate ranges. No spaces or ';'
    831   //              are allowed.
     856  //              extract. The form of the string is "0,4-6,8-12" with only numbers
     857  //              and '-' for range or ',' to separate ranges. No spaces or ';'
     858  //              are allowed.
    832859  //   $p_path : Path where the files and directories are to be extracted
    833860  //   $p_remove_path : First part ('root' part) of the memorized path
    834   //                    (if any similar) to remove while extracting.
     861  //                    (if any similar) to remove while extracting.
    835862  // Options :
    836863  //   PCLZIP_OPT_PATH :
     
    839866  //   PCLZIP_OPT_REMOVE_ALL_PATH :
    840867  //   PCLZIP_OPT_EXTRACT_AS_STRING : The files are extracted as strings and
    841   //    not as files.
    842   //    The resulting content is in a new field 'content' in the file
    843   //    structure.
    844   //    This option must be used alone (any other options are ignored).
     868  //    not as files.
     869  //    The resulting content is in a new field 'content' in the file
     870  //    structure.
     871  //    This option must be used alone (any other options are ignored).
    845872  //   PCLZIP_CB_PRE_EXTRACT :
    846873  //   PCLZIP_CB_POST_EXTRACT :
     
    853880  function extractByIndex($p_index)
    854881  {
    855     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::extractByIndex", "index='$p_index', ...");
    856     $v_result=1;
    857 
    858     // ----- Reset the error handler
    859     $this->privErrorReset();
    860 
    861     // ----- Check archive
    862     if (!$this->privCheckFormat()) {
    863       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    864       return(0);
    865     }
    866 
    867     // ----- Set default values
    868     $v_options = array();
    869 //    $v_path = "./";
    870     $v_path = '';
    871     $v_remove_path = "";
    872     $v_remove_all_path = false;
    873 
    874     // ----- Look for variable options arguments
    875     $v_size = func_num_args();
    876     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    877 
    878     // ----- Default values for option
    879     $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
    880 
    881     // ----- Look for arguments
    882     if ($v_size > 1) {
    883       // ----- Get the arguments
    884       $v_arg_list = func_get_args();
    885 
    886       // ----- Remove form the options list the first argument
    887       array_shift($v_arg_list);
    888       $v_size--;
    889 
    890       // ----- Look for first arg
    891       if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    892         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options");
    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'
     882    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::extractByIndex", "index='$p_index', ...");
     883    $v_result=1;
     884
     885    // ----- Reset the error handler
     886    $this->privErrorReset();
     887
     888    // ----- Check archive
     889    if (!$this->privCheckFormat()) {
     890      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     891      return(0);
     892    }
     893
     894    // ----- Set default values
     895    $v_options = array();
     896//  $v_path = "./";
     897    $v_path = '';
     898    $v_remove_path = "";
     899    $v_remove_all_path = false;
     900
     901    // ----- Look for variable options arguments
     902    $v_size = func_num_args();
     903    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
     904
     905    // ----- Default values for option
     906    $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
     907
     908    // ----- Look for arguments
     909    if ($v_size > 1) {
     910      // ----- Get the arguments
     911      $v_arg_list = func_get_args();
     912
     913      // ----- Remove form the options list the first argument
     914      array_shift($v_arg_list);
     915      $v_size--;
     916
     917      // ----- Look for first arg
     918      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
     919        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options");
     920
     921        // ----- Parse the options
     922        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
     923                                            array (PCLZIP_OPT_PATH => 'optional',
     924                                                   PCLZIP_OPT_REMOVE_PATH => 'optional',
     925                                                   PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
     926                                                   PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
     927                                                   PCLZIP_OPT_ADD_PATH => 'optional',
     928                                                   PCLZIP_CB_PRE_EXTRACT => 'optional',
     929                                                   PCLZIP_CB_POST_EXTRACT => 'optional',
     930                                                   PCLZIP_OPT_SET_CHMOD => 'optional',
     931                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'
     932                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
     933                                                   ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional'
    907934                                                   ));
    908         if ($v_result != 1) {
    909           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    910           return 0;
    911         }
    912 
    913         // ----- Set the arguments
    914         if (isset($v_options[PCLZIP_OPT_PATH])) {
    915           $v_path = $v_options[PCLZIP_OPT_PATH];
    916         }
    917         if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
    918           $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
    919         }
    920         if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
    921           $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
    922         }
    923         if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
    924           // ----- Check for '/' in last path char
    925           if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
    926             $v_path .= '/';
    927           }
    928           $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
    929         }
    930         if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {
    931           $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
    932           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Option PCLZIP_OPT_EXTRACT_AS_STRING not set.");
    933         }
    934         else {
    935             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Option PCLZIP_OPT_EXTRACT_AS_STRING set.");
    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         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    944 
    945         // ----- Get the first argument
    946         $v_path = $v_arg_list[0];
    947 
    948         // ----- Look for the optional second argument
    949         if ($v_size == 2) {
    950           $v_remove_path = $v_arg_list[1];
    951         }
    952         else if ($v_size > 2) {
    953           // ----- Error log
    954           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
    955 
    956           // ----- Return
    957           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    958           return 0;
    959         }
    960       }
    961     }
    962 
    963     // ----- Trace
    964     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "index='$p_index', path='$v_path', remove_path='$v_remove_path', remove_all_path='".($v_remove_path?'true':'false')."'");
    965 
    966     // ----- Trick
    967     // Here I want to reuse extractByRule(), so I need to parse the $p_index
    968     // with privParseOptions()
    969     $v_arg_trick = array (PCLZIP_OPT_BY_INDEX, $p_index);
    970     $v_options_trick = array();
    971     $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,
    972                                         array (PCLZIP_OPT_BY_INDEX => 'optional' ));
    973     if ($v_result != 1) {
    974         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    975         return 0;
    976     }
    977     $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
    978 
    979     // ----- Call the extracting fct
    980     if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {
    981         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    982         return(0);
    983     }
    984 
    985     // ----- Return
    986     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    987     return $p_list;
     935        if ($v_result != 1) {
     936          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     937          return 0;
     938        }
     939
     940        // ----- Set the arguments
     941        if (isset($v_options[PCLZIP_OPT_PATH])) {
     942          $v_path = $v_options[PCLZIP_OPT_PATH];
     943        }
     944        if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
     945          $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
     946        }
     947        if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
     948          $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
     949        }
     950        if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
     951          // ----- Check for '/' in last path char
     952          if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
     953            $v_path .= '/';
     954          }
     955          $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
     956        }
     957        if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {
     958          $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
     959          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Option PCLZIP_OPT_EXTRACT_AS_STRING not set.");
     960        }
     961        else {
     962            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Option PCLZIP_OPT_EXTRACT_AS_STRING set.");
     963        }
     964      }
     965
     966      // ----- Look for 2 args
     967      // Here we need to support the first historic synopsis of the
     968      // method.
     969      else {
     970        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
     971
     972        // ----- Get the first argument
     973        $v_path = $v_arg_list[0];
     974
     975        // ----- Look for the optional second argument
     976        if ($v_size == 2) {
     977          $v_remove_path = $v_arg_list[1];
     978        }
     979        else if ($v_size > 2) {
     980          // ----- Error log
     981          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
     982
     983          // ----- Return
     984          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     985          return 0;
     986        }
     987      }
     988    }
     989
     990    // ----- Trace
     991    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "index='$p_index', path='$v_path', remove_path='$v_remove_path', remove_all_path='".($v_remove_path?'true':'false')."'");
     992
     993    // ----- Trick
     994    // Here I want to reuse extractByRule(), so I need to parse the $p_index
     995    // with privParseOptions()
     996    $v_arg_trick = array (PCLZIP_OPT_BY_INDEX, $p_index);
     997    $v_options_trick = array();
     998    $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,
     999                                        array (PCLZIP_OPT_BY_INDEX => 'optional' ));
     1000    if ($v_result != 1) {
     1001        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     1002        return 0;
     1003    }
     1004    $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
     1005
     1006    // ----- Call the extracting fct
     1007    if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {
     1008        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
     1009        return(0);
     1010    }
     1011
     1012    // ----- Return
     1013    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
     1014    return $p_list;
    9881015  }
    9891016  // --------------------------------------------------------------------------------
     
    10001027  //   PCLZIP_OPT_BY_INDEX :
    10011028  //   PCLZIP_OPT_BY_NAME :
    1002   //   PCLZIP_OPT_BY_EREG :
     1029  //   PCLZIP_OPT_BY_EREG : 
    10031030  //   PCLZIP_OPT_BY_PREG :
    10041031  // Return Values :
     
    10091036  function delete()
    10101037  {
    1011     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::delete", "");
    1012     $v_result=1;
    1013 
    1014     // ----- Reset the error handler
    1015     $this->privErrorReset();
    1016 
    1017     // ----- Check archive
    1018     if (!$this->privCheckFormat()) {
    1019       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    1020       return(0);
    1021     }
    1022 
    1023     // ----- Set default values
    1024     $v_options = array();
    1025 
    1026     // ----- Look for variable options arguments
    1027     $v_size = func_num_args();
    1028     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    1029 
    1030     // ----- Look for arguments
    1031     if ($v_size > 0) {
    1032       // ----- Get the arguments
    1033       $v_arg_list = func_get_args();
    1034 
    1035       // ----- Parse the options
    1036       $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
    1037                                         array (PCLZIP_OPT_BY_NAME => 'optional',
    1038                                                PCLZIP_OPT_BY_EREG => 'optional',
    1039                                                PCLZIP_OPT_BY_PREG => 'optional',
    1040                                                PCLZIP_OPT_BY_INDEX => 'optional' ));
    1041       if ($v_result != 1) {
    1042           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    1043           return 0;
    1044       }
    1045     }
    1046 
    1047     // ----- Magic quotes trick
    1048     $this->privDisableMagicQuotes();
    1049 
    1050     // ----- Call the delete fct
    1051     $v_list = array();
    1052     if (($v_result = $this->privDeleteByRule($v_list, $v_options)) != 1) {
    1053       $this->privSwapBackMagicQuotes();
    1054       unset($v_list);
    1055       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    1056       return(0);
    1057     }
    1058 
    1059     // ----- Magic quotes trick
    1060     $this->privSwapBackMagicQuotes();
    1061 
    1062     // ----- Return
    1063     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_list);
    1064     return $v_list;
     1038    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::delete", "");
     1039    $v_result=1;
     1040
     1041    // ----- Reset the error handler
     1042    $this->privErrorReset();
     1043
     1044    // ----- Check archive
     1045    if (!$this->privCheckFormat()) {
     1046      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     1047      return(0);
     1048    }
     1049
     1050    // ----- Set default values
     1051    $v_options = array();
     1052
     1053    // ----- Look for variable options arguments
     1054    $v_size = func_num_args();
     1055    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
     1056
     1057    // ----- Look for arguments
     1058    if ($v_size > 0) {
     1059      // ----- Get the arguments
     1060      $v_arg_list = func_get_args();
     1061
     1062      // ----- Parse the options
     1063      $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
     1064                                        array (PCLZIP_OPT_BY_NAME => 'optional',
     1065                                               PCLZIP_OPT_BY_EREG => 'optional',
     1066                                               PCLZIP_OPT_BY_PREG => 'optional',
     1067                                               PCLZIP_OPT_BY_INDEX => 'optional' ));
     1068      if ($v_result != 1) {
     1069          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     1070          return 0;
     1071      }
     1072    }
     1073
     1074    // ----- Magic quotes trick
     1075    $this->privDisableMagicQuotes();
     1076
     1077    // ----- Call the delete fct
     1078    $v_list = array();
     1079    if (($v_result = $this->privDeleteByRule($v_list, $v_options)) != 1) {
     1080      $this->privSwapBackMagicQuotes();
     1081      unset($v_list);
     1082      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
     1083      return(0);
     1084    }
     1085
     1086    // ----- Magic quotes trick
     1087    $this->privSwapBackMagicQuotes();
     1088
     1089    // ----- Return
     1090    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_list);
     1091    return $v_list;
    10651092  }
    10661093  // --------------------------------------------------------------------------------
     
    10741101  function deleteByIndex($p_index)
    10751102  {
    1076     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::deleteByIndex", "index='$p_index'");
    1077 
    1078     $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
    1079 
    1080     // ----- Return
    1081     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    1082     return $p_list;
     1103    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::deleteByIndex", "index='$p_index'");
     1104   
     1105    $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
     1106
     1107    // ----- Return
     1108    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
     1109    return $p_list;
    10831110  }
    10841111  // --------------------------------------------------------------------------------
     
    10891116  //   This method gives the properties of the archive.
    10901117  //   The properties are :
    1091   //    nb : Number of files in the archive
    1092   //    comment : Comment associated with the archive file
    1093   //    status : not_exist, ok
     1118  //    nb : Number of files in the archive
     1119  //    comment : Comment associated with the archive file
     1120  //    status : not_exist, ok
    10941121  // Parameters :
    10951122  //   None
     
    11001127  function properties()
    11011128  {
    1102     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::properties", "");
    1103 
    1104     // ----- Reset the error handler
    1105     $this->privErrorReset();
    1106 
    1107     // ----- Magic quotes trick
    1108     $this->privDisableMagicQuotes();
    1109 
    1110     // ----- Check archive
    1111     if (!$this->privCheckFormat()) {
    1112       $this->privSwapBackMagicQuotes();
    1113       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    1114       return(0);
    1115     }
    1116 
    1117     // ----- Default properties
    1118     $v_prop = array();
    1119     $v_prop['comment'] = '';
    1120     $v_prop['nb'] = 0;
    1121     $v_prop['status'] = 'not_exist';
    1122 
    1123     // ----- Look if file exists
    1124     if (@is_file($this->zipname))
    1125     {
    1126       // ----- Open the zip file
    1127       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    1128       if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
    1129       {
    1130         $this->privSwapBackMagicQuotes();
    1131 
    1132         // ----- Error log
    1133         PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
    1134 
    1135         // ----- Return
    1136         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), 0);
    1137         return 0;
    1138       }
    1139 
    1140       // ----- Read the central directory informations
    1141       $v_central_dir = array();
    1142       if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
    1143       {
    1144         $this->privSwapBackMagicQuotes();
    1145         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    1146         return 0;
    1147       }
    1148 
    1149       // ----- Close the zip file
    1150       $this->privCloseFd();
    1151 
    1152       // ----- Set the user attributes
    1153       $v_prop['comment'] = $v_central_dir['comment'];
    1154       $v_prop['nb'] = $v_central_dir['entries'];
    1155       $v_prop['status'] = 'ok';
    1156     }
    1157 
    1158     // ----- Magic quotes trick
    1159     $this->privSwapBackMagicQuotes();
    1160 
    1161     // ----- Return
    1162     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_prop);
    1163     return $v_prop;
     1129    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::properties", "");
     1130
     1131    // ----- Reset the error handler
     1132    $this->privErrorReset();
     1133
     1134    // ----- Magic quotes trick
     1135    $this->privDisableMagicQuotes();
     1136
     1137    // ----- Check archive
     1138    if (!$this->privCheckFormat()) {
     1139      $this->privSwapBackMagicQuotes();
     1140      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     1141      return(0);
     1142    }
     1143
     1144    // ----- Default properties
     1145    $v_prop = array();
     1146    $v_prop['comment'] = '';
     1147    $v_prop['nb'] = 0;
     1148    $v_prop['status'] = 'not_exist';
     1149
     1150    // ----- Look if file exists
     1151    if (@is_file($this->zipname))
     1152    {
     1153      // ----- Open the zip file
     1154      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
     1155      if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
     1156      {
     1157        $this->privSwapBackMagicQuotes();
     1158       
     1159        // ----- Error log
     1160        PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
     1161
     1162        // ----- Return
     1163        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), 0);
     1164        return 0;
     1165      }
     1166
     1167      // ----- Read the central directory informations
     1168      $v_central_dir = array();
     1169      if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
     1170      {
     1171        $this->privSwapBackMagicQuotes();
     1172        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     1173        return 0;
     1174      }
     1175
     1176      // ----- Close the zip file
     1177      $this->privCloseFd();
     1178
     1179      // ----- Set the user attributes
     1180      $v_prop['comment'] = $v_central_dir['comment'];
     1181      $v_prop['nb'] = $v_central_dir['entries'];
     1182      $v_prop['status'] = 'ok';
     1183    }
     1184
     1185    // ----- Magic quotes trick
     1186    $this->privSwapBackMagicQuotes();
     1187
     1188    // ----- Return
     1189    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_prop);
     1190    return $v_prop;
    11641191  }
    11651192  // --------------------------------------------------------------------------------
     
    11721199  // Parameters :
    11731200  //   $p_archive : The filename of a valid archive, or
    1174   //                a valid PclZip object.
     1201  //                a valid PclZip object.
    11751202  // Return Values :
    11761203  //   1 on success.
     
    11791206  function duplicate($p_archive)
    11801207  {
    1181     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::duplicate", "");
    1182     $v_result = 1;
    1183 
    1184     // ----- Reset the error handler
    1185     $this->privErrorReset();
    1186 
    1187     // ----- Look if the $p_archive is a PclZip object
    1188     if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
    1189     {
    1190       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The parameter is valid PclZip object '".$p_archive->zipname."'");
    1191 
    1192       // ----- Duplicate the archive
    1193       $v_result = $this->privDuplicate($p_archive->zipname);
    1194     }
    1195 
    1196     // ----- Look if the $p_archive is a string (so a filename)
    1197     else if (is_string($p_archive))
    1198     {
    1199       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The parameter is a filename '$p_archive'");
    1200 
    1201       // ----- Check that $p_archive is a valid zip file
    1202       // TBC : Should also check the archive format
    1203       if (!is_file($p_archive)) {
    1204         // ----- Error log
    1205         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '".$p_archive."'");
    1206         $v_result = PCLZIP_ERR_MISSING_FILE;
    1207       }
    1208       else {
    1209         // ----- Duplicate the archive
    1210         $v_result = $this->privDuplicate($p_archive);
    1211       }
    1212     }
    1213 
    1214     // ----- Invalid variable
    1215     else
    1216     {
    1217       // ----- Error log
    1218       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
    1219       $v_result = PCLZIP_ERR_INVALID_PARAMETER;
    1220     }
    1221 
    1222     // ----- Return
    1223     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    1224     return $v_result;
     1208    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::duplicate", "");
     1209    $v_result = 1;
     1210
     1211    // ----- Reset the error handler
     1212    $this->privErrorReset();
     1213
     1214    // ----- Look if the $p_archive is a PclZip object
     1215    if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
     1216    {
     1217      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The parameter is valid PclZip object '".$p_archive->zipname."'");
     1218
     1219      // ----- Duplicate the archive
     1220      $v_result = $this->privDuplicate($p_archive->zipname);
     1221    }
     1222
     1223    // ----- Look if the $p_archive is a string (so a filename)
     1224    else if (is_string($p_archive))
     1225    {
     1226      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The parameter is a filename '$p_archive'");
     1227
     1228      // ----- Check that $p_archive is a valid zip file
     1229      // TBC : Should also check the archive format
     1230      if (!is_file($p_archive)) {
     1231        // ----- Error log
     1232        PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '".$p_archive."'");
     1233        $v_result = PCLZIP_ERR_MISSING_FILE;
     1234      }
     1235      else {
     1236        // ----- Duplicate the archive
     1237        $v_result = $this->privDuplicate($p_archive);
     1238      }
     1239    }
     1240
     1241    // ----- Invalid variable
     1242    else
     1243    {
     1244      // ----- Error log
     1245      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
     1246      $v_result = PCLZIP_ERR_INVALID_PARAMETER;
     1247    }
     1248
     1249    // ----- Return
     1250    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     1251    return $v_result;
    12251252  }
    12261253  // --------------------------------------------------------------------------------
     
    12351262  // Parameters :
    12361263  //   $p_archive_to_add : It can be directly the filename of a valid zip archive,
    1237   //                       or a PclZip object archive.
     1264  //                       or a PclZip object archive.
    12381265  // Return Values :
    12391266  //   1 on success,
     
    12421269  function merge($p_archive_to_add)
    12431270  {
    1244     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::merge", "");
    1245     $v_result = 1;
    1246 
    1247     // ----- Reset the error handler
    1248     $this->privErrorReset();
    1249 
    1250     // ----- Check archive
    1251     if (!$this->privCheckFormat()) {
    1252       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    1253       return(0);
    1254     }
    1255 
    1256     // ----- Look if the $p_archive_to_add is a PclZip object
    1257     if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
    1258     {
    1259       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The parameter is valid PclZip object");
    1260 
    1261       // ----- Merge the archive
    1262       $v_result = $this->privMerge($p_archive_to_add);
    1263     }
    1264 
    1265     // ----- Look if the $p_archive_to_add is a string (so a filename)
    1266     else if (is_string($p_archive_to_add))
    1267     {
    1268       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The parameter is a filename");
    1269 
    1270       // ----- Create a temporary archive
    1271       $v_object_archive = new PclZip($p_archive_to_add);
    1272 
    1273       // ----- Merge the archive
    1274       $v_result = $this->privMerge($v_object_archive);
    1275     }
    1276 
    1277     // ----- Invalid variable
    1278     else
    1279     {
    1280       // ----- Error log
    1281       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
    1282       $v_result = PCLZIP_ERR_INVALID_PARAMETER;
    1283     }
    1284 
    1285     // ----- Return
    1286     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    1287     return $v_result;
     1271    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::merge", "");
     1272    $v_result = 1;
     1273
     1274    // ----- Reset the error handler
     1275    $this->privErrorReset();
     1276
     1277    // ----- Check archive
     1278    if (!$this->privCheckFormat()) {
     1279      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
     1280      return(0);
     1281    }
     1282
     1283    // ----- Look if the $p_archive_to_add is a PclZip object
     1284    if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
     1285    {
     1286      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The parameter is valid PclZip object");
     1287
     1288      // ----- Merge the archive
     1289      $v_result = $this->privMerge($p_archive_to_add);
     1290    }
     1291
     1292    // ----- Look if the $p_archive_to_add is a string (so a filename)
     1293    else if (is_string($p_archive_to_add))
     1294    {
     1295      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The parameter is a filename");
     1296
     1297      // ----- Create a temporary archive
     1298      $v_object_archive = new PclZip($p_archive_to_add);
     1299
     1300      // ----- Merge the archive
     1301      $v_result = $this->privMerge($v_object_archive);
     1302    }
     1303
     1304    // ----- Invalid variable
     1305    else
     1306    {
     1307      // ----- Error log
     1308      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
     1309      $v_result = PCLZIP_ERR_INVALID_PARAMETER;
     1310    }
     1311
     1312    // ----- Return
     1313    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     1314    return $v_result;
    12881315  }
    12891316  // --------------------------------------------------------------------------------
     
    12981325  function errorCode()
    12991326  {
    1300     if (PCLZIP_ERROR_EXTERNAL == 1) {
    1301       return(PclErrorCode());
    1302     }
    1303     else {
    1304       return($this->error_code);
    1305     }
     1327    if (PCLZIP_ERROR_EXTERNAL == 1) {
     1328      return(PclErrorCode());
     1329    }
     1330    else {
     1331      return($this->error_code);
     1332    }
    13061333  }
    13071334  // --------------------------------------------------------------------------------
     
    13141341  function errorName($p_with_code=false)
    13151342  {
    1316     $v_name = array ( PCLZIP_ERR_NO_ERROR => 'PCLZIP_ERR_NO_ERROR',
    1317                       PCLZIP_ERR_WRITE_OPEN_FAIL => 'PCLZIP_ERR_WRITE_OPEN_FAIL',
    1318                       PCLZIP_ERR_READ_OPEN_FAIL => 'PCLZIP_ERR_READ_OPEN_FAIL',
    1319                       PCLZIP_ERR_INVALID_PARAMETER => 'PCLZIP_ERR_INVALID_PARAMETER',
    1320                       PCLZIP_ERR_MISSING_FILE => 'PCLZIP_ERR_MISSING_FILE',
    1321                       PCLZIP_ERR_FILENAME_TOO_LONG => 'PCLZIP_ERR_FILENAME_TOO_LONG',
    1322                       PCLZIP_ERR_INVALID_ZIP => 'PCLZIP_ERR_INVALID_ZIP',
    1323                       PCLZIP_ERR_BAD_EXTRACTED_FILE => 'PCLZIP_ERR_BAD_EXTRACTED_FILE',
    1324                       PCLZIP_ERR_DIR_CREATE_FAIL => 'PCLZIP_ERR_DIR_CREATE_FAIL',
    1325                       PCLZIP_ERR_BAD_EXTENSION => 'PCLZIP_ERR_BAD_EXTENSION',
    1326                       PCLZIP_ERR_BAD_FORMAT => 'PCLZIP_ERR_BAD_FORMAT',
    1327                       PCLZIP_ERR_DELETE_FILE_FAIL => 'PCLZIP_ERR_DELETE_FILE_FAIL',
    1328                       PCLZIP_ERR_RENAME_FILE_FAIL => 'PCLZIP_ERR_RENAME_FILE_FAIL',
    1329                       PCLZIP_ERR_BAD_CHECKSUM => 'PCLZIP_ERR_BAD_CHECKSUM',
    1330                       PCLZIP_ERR_INVALID_ARCHIVE_ZIP => 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP',
    1331                       PCLZIP_ERR_MISSING_OPTION_VALUE => 'PCLZIP_ERR_MISSING_OPTION_VALUE',
    1332                       PCLZIP_ERR_INVALID_OPTION_VALUE => 'PCLZIP_ERR_INVALID_OPTION_VALUE',
    1333                       PCLZIP_ERR_UNSUPPORTED_COMPRESSION => 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION',
    1334                       PCLZIP_ERR_UNSUPPORTED_ENCRYPTION => 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION'
    1335                       ,PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE => 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE'
    1336                       ,PCLZIP_ERR_DIRECTORY_RESTRICTION => 'PCLZIP_ERR_DIRECTORY_RESTRICTION'
    1337                     );
    1338 
    1339     if (isset($v_name[$this->error_code])) {
    1340       $v_value = $v_name[$this->error_code];
    1341     }
    1342     else {
    1343       $v_value = 'NoName';
    1344     }
    1345 
    1346     if ($p_with_code) {
    1347       return($v_value.' ('.$this->error_code.')');
    1348     }
    1349     else {
    1350       return($v_value);
    1351     }
     1343    $v_name = array ( PCLZIP_ERR_NO_ERROR => 'PCLZIP_ERR_NO_ERROR',
     1344                      PCLZIP_ERR_WRITE_OPEN_FAIL => 'PCLZIP_ERR_WRITE_OPEN_FAIL',
     1345                      PCLZIP_ERR_READ_OPEN_FAIL => 'PCLZIP_ERR_READ_OPEN_FAIL',
     1346                      PCLZIP_ERR_INVALID_PARAMETER => 'PCLZIP_ERR_INVALID_PARAMETER',
     1347                      PCLZIP_ERR_MISSING_FILE => 'PCLZIP_ERR_MISSING_FILE',
     1348                      PCLZIP_ERR_FILENAME_TOO_LONG => 'PCLZIP_ERR_FILENAME_TOO_LONG',
     1349                      PCLZIP_ERR_INVALID_ZIP => 'PCLZIP_ERR_INVALID_ZIP',
     1350                      PCLZIP_ERR_BAD_EXTRACTED_FILE => 'PCLZIP_ERR_BAD_EXTRACTED_FILE',
     1351                      PCLZIP_ERR_DIR_CREATE_FAIL => 'PCLZIP_ERR_DIR_CREATE_FAIL',
     1352                      PCLZIP_ERR_BAD_EXTENSION => 'PCLZIP_ERR_BAD_EXTENSION',
     1353                      PCLZIP_ERR_BAD_FORMAT => 'PCLZIP_ERR_BAD_FORMAT',
     1354                      PCLZIP_ERR_DELETE_FILE_FAIL => 'PCLZIP_ERR_DELETE_FILE_FAIL',
     1355                      PCLZIP_ERR_RENAME_FILE_FAIL => 'PCLZIP_ERR_RENAME_FILE_FAIL',
     1356                      PCLZIP_ERR_BAD_CHECKSUM => 'PCLZIP_ERR_BAD_CHECKSUM',
     1357                      PCLZIP_ERR_INVALID_ARCHIVE_ZIP => 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP',
     1358                      PCLZIP_ERR_MISSING_OPTION_VALUE => 'PCLZIP_ERR_MISSING_OPTION_VALUE',
     1359                      PCLZIP_ERR_INVALID_OPTION_VALUE => 'PCLZIP_ERR_INVALID_OPTION_VALUE',
     1360                      PCLZIP_ERR_UNSUPPORTED_COMPRESSION => 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION',
     1361                      PCLZIP_ERR_UNSUPPORTED_ENCRYPTION => 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION',
     1362                      PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE => 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE',
     1363                      PCLZIP_ERR_DIRECTORY_RESTRICTION => 'PCLZIP_ERR_DIRECTORY_RESTRICTION'
     1364                    );
     1365
     1366    if (isset($v_name[$this->error_code])) {
     1367      $v_value = $v_name[$this->error_code];
     1368    }
     1369    else {
     1370      $v_value = 'NoName';
     1371    }
     1372
     1373    if ($p_with_code) {
     1374      return($v_value.' ('.$this->error_code.')');
     1375    }
     1376    else {
     1377      return($v_value);
     1378    }
    13521379  }
    13531380  // --------------------------------------------------------------------------------
     
    13601387  function errorInfo($p_full=false)
    13611388  {
    1362     if (PCLZIP_ERROR_EXTERNAL == 1) {
    1363       return(PclErrorString());
    1364     }
    1365     else {
    1366       if ($p_full) {
    1367         return($this->errorName(true)." : ".$this->error_string);
    1368       }
    1369       else {
    1370         return($this->error_string." [code ".$this->error_code."]");
    1371       }
    1372     }
     1389    if (PCLZIP_ERROR_EXTERNAL == 1) {
     1390      return(PclErrorString());
     1391    }
     1392    else {
     1393      if ($p_full) {
     1394        return($this->errorName(true)." : ".$this->error_string);
     1395      }
     1396      else {
     1397        return($this->error_string." [code ".$this->error_code."]");
     1398      }
     1399    }
    13731400  }
    13741401  // --------------------------------------------------------------------------------
     
    13771404// --------------------------------------------------------------------------------
    13781405// ***** UNDER THIS LINE ARE DEFINED PRIVATE INTERNAL FUNCTIONS *****
    1379 // *****                                                        *****
    1380 // *****       THESES FUNCTIONS MUST NOT BE USED DIRECTLY       *****
     1406// *****       THESES FUNCTIONS MUST NOT BE USED DIRECTLY      *****
    13811407// --------------------------------------------------------------------------------
    13821408
     
    13901416  // Parameters :
    13911417  //   $p_level : Level of check. Default 0.
    1392   //              0 : Check the first bytes (magic codes) (default value))
    1393   //              1 : 0 + Check the central directory (futur)
    1394   //              2 : 1 + Check each file header (futur)
     1418  //              0 : Check the first bytes (magic codes) (default value))
     1419  //              1 : 0 + Check the central directory (futur)
     1420  //              2 : 1 + Check each file header (futur)
    13951421  // Return Values :
    13961422  //   true on success,
     
    13991425  function privCheckFormat($p_level=0)
    14001426  {
    1401     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCheckFormat", "");
    1402     $v_result = true;
     1427    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCheckFormat", "");
     1428    $v_result = true;
    14031429
    14041430    // ----- Reset the file system cache
    1405     clearstatcache();
    1406 
    1407     // ----- Reset the error handler
    1408     $this->privErrorReset();
    1409 
    1410     // ----- Look if the file exits
    1411     if (!is_file($this->zipname)) {
    1412       // ----- Error log
    1413       PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
    1414       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, false, PclZip::errorInfo());
    1415       return(false);
    1416     }
    1417 
    1418     // ----- Check that the file is readeable
    1419     if (!is_readable($this->zipname)) {
    1420       // ----- Error log
    1421       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
    1422       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, false, PclZip::errorInfo());
    1423       return(false);
    1424     }
    1425 
    1426     // ----- Check the magic code
    1427     // TBC
    1428 
    1429     // ----- Check the central header
    1430     // TBC
    1431 
    1432     // ----- Check each file header
    1433     // TBC
    1434 
    1435     // ----- Return
    1436     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    1437     return $v_result;
     1431    clearstatcache();
     1432
     1433    // ----- Reset the error handler
     1434    $this->privErrorReset();
     1435
     1436    // ----- Look if the file exits
     1437    if (!is_file($this->zipname)) {
     1438      // ----- Error log
     1439      PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
     1440      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, false, PclZip::errorInfo());
     1441      return(false);
     1442    }
     1443
     1444    // ----- Check that the file is readeable
     1445    if (!is_readable($this->zipname)) {
     1446      // ----- Error log
     1447      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
     1448      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, false, PclZip::errorInfo());
     1449      return(false);
     1450    }
     1451
     1452    // ----- Check the magic code
     1453    // TBC
     1454
     1455    // ----- Check the central header
     1456    // TBC
     1457
     1458    // ----- Check each file header
     1459    // TBC
     1460
     1461    // ----- Return
     1462    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     1463    return $v_result;
    14381464  }
    14391465  // --------------------------------------------------------------------------------
     
    14561482  function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)
    14571483  {
    1458     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privParseOptions", "");
    1459     $v_result=1;
    1460 
    1461     // ----- Read the options
    1462     $i=0;
    1463     while ($i<$p_size) {
    1464       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Looking for table index $i, option = '".PclZipUtilOptionText($p_options_list[$i])."(".$p_options_list[$i].")'");
    1465 
    1466       // ----- Check if the option is supported
    1467       if (!isset($v_requested_options[$p_options_list[$i]])) {
    1468         // ----- Error log
    1469         PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");
    1470 
    1471         // ----- Return
    1472         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1473         return PclZip::errorCode();
    1474       }
    1475 
    1476       // ----- Look for next option
    1477       switch ($p_options_list[$i]) {
    1478         // ----- Look for options that request a path value
    1479         case PCLZIP_OPT_PATH :
    1480         case PCLZIP_OPT_REMOVE_PATH :
    1481         case PCLZIP_OPT_ADD_PATH :
    1482           // ----- Check the number of parameters
    1483           if (($i+1) >= $p_size) {
    1484             // ----- Error log
    1485             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1486 
    1487             // ----- Return
    1488             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1489             return PclZip::errorCode();
    1490           }
    1491 
    1492           // ----- Get the value
    1493           $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], false);
    1494           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    1495           $i++;
    1496         break;
    1497 
    1498         case PCLZIP_OPT_EXTRACT_DIR_RESTRICTION :
    1499           // ----- Check the number of parameters
    1500           if (($i+1) >= $p_size) {
    1501             // ----- Error log
    1502             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1503 
    1504             // ----- Return
    1505             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1506             return PclZip::errorCode();
    1507           }
    1508 
    1509           // ----- Get the value
    1510           if (   is_string($p_options_list[$i+1])
    1511               && ($p_options_list[$i+1] != '')) {
    1512             $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], false);
    1513             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    1514             $i++;
    1515           }
    1516           else {
    1517             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." set with an empty value is ignored.");
    1518           }
    1519         break;
    1520 
    1521         // ----- Look for options that request an array of string for value
    1522         case PCLZIP_OPT_BY_NAME :
    1523           // ----- Check the number of parameters
    1524           if (($i+1) >= $p_size) {
    1525             // ----- Error log
    1526             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1527 
    1528             // ----- Return
    1529             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1530             return PclZip::errorCode();
    1531           }
    1532 
    1533           // ----- Get the value
    1534           if (is_string($p_options_list[$i+1])) {
    1535               $v_result_list[$p_options_list[$i]][0] = $p_options_list[$i+1];
    1536           }
    1537           else if (is_array($p_options_list[$i+1])) {
    1538               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1539           }
    1540           else {
    1541             // ----- Error log
    1542             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1543 
    1544             // ----- Return
    1545             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1546             return PclZip::errorCode();
    1547           }
    1548           ////--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    1549           $i++;
    1550         break;
    1551 
    1552         // ----- Look for options that request an EREG or PREG expression
    1553         case PCLZIP_OPT_BY_EREG :
    1554         case PCLZIP_OPT_BY_PREG :
    1555         //case PCLZIP_OPT_CRYPT :
    1556           // ----- Check the number of parameters
    1557           if (($i+1) >= $p_size) {
    1558             // ----- Error log
    1559             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1560 
    1561             // ----- Return
    1562             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1563             return PclZip::errorCode();
    1564           }
    1565 
    1566           // ----- Get the value
    1567           if (is_string($p_options_list[$i+1])) {
    1568               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1569           }
    1570           else {
    1571             // ----- Error log
    1572             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1573 
    1574             // ----- Return
    1575             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1576             return PclZip::errorCode();
    1577           }
    1578           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    1579           $i++;
    1580         break;
    1581 
    1582         // ----- Look for options that takes a string
    1583         case PCLZIP_OPT_COMMENT :
    1584         case PCLZIP_OPT_ADD_COMMENT :
    1585         case PCLZIP_OPT_PREPEND_COMMENT :
    1586           // ----- Check the number of parameters
    1587           if (($i+1) >= $p_size) {
    1588             // ----- Error log
    1589             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
    1590                                  "Missing parameter value for option '"
     1484    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privParseOptions", "");
     1485    $v_result=1;
     1486   
     1487    // ----- Read the options
     1488    $i=0;
     1489    while ($i<$p_size) {
     1490      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Looking for table index $i, option = '".PclZipUtilOptionText($p_options_list[$i])."(".$p_options_list[$i].")'");
     1491
     1492      // ----- Check if the option is supported
     1493      if (!isset($v_requested_options[$p_options_list[$i]])) {
     1494        // ----- Error log
     1495        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");
     1496
     1497        // ----- Return
     1498        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1499        return PclZip::errorCode();
     1500      }
     1501
     1502      // ----- Look for next option
     1503      switch ($p_options_list[$i]) {
     1504        // ----- Look for options that request a path value
     1505        case PCLZIP_OPT_PATH :
     1506        case PCLZIP_OPT_REMOVE_PATH :
     1507        case PCLZIP_OPT_ADD_PATH :
     1508          // ----- Check the number of parameters
     1509          if (($i+1) >= $p_size) {
     1510            // ----- Error log
     1511            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1512
     1513            // ----- Return
     1514            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1515            return PclZip::errorCode();
     1516          }
     1517
     1518          // ----- Get the value
     1519          $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
     1520          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1521          $i++;
     1522        break;
     1523
     1524        case PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD :
     1525          // ----- Check the number of parameters
     1526          if (($i+1) >= $p_size) {
     1527            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1528            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1529            return PclZip::errorCode();
     1530          }
     1531         
     1532          // ----- Check for incompatible options
     1533          if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_OFF])) {
     1534            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_OFF'");
     1535            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1536            return PclZip::errorCode();
     1537          }
     1538         
     1539          // ----- Check the value
     1540          $v_value = $p_options_list[$i+1];
     1541          if ((!is_integer($v_value)) || ($v_value<0)) {
     1542            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Integer expected for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1543            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1544            return PclZip::errorCode();
     1545          }
     1546
     1547          // ----- Get the value (and convert it in bytes)
     1548          $v_result_list[$p_options_list[$i]] = $v_value*1048576;
     1549          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1550          $i++;
     1551        break;
     1552
     1553        case PCLZIP_OPT_ADD_TEMP_FILE_ON :
     1554          // ----- Check for incompatible options
     1555          if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_OFF])) {
     1556            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_OFF'");
     1557            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1558            return PclZip::errorCode();
     1559          }
     1560         
     1561          $v_result_list[$p_options_list[$i]] = true;
     1562          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1563        break;
     1564
     1565        case PCLZIP_OPT_ADD_TEMP_FILE_OFF :
     1566          // ----- Check for incompatible options
     1567          if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_ON])) {
     1568            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_ON'");
     1569            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1570            return PclZip::errorCode();
     1571          }
     1572          // ----- Check for incompatible options
     1573          if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
     1574            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD'");
     1575            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1576            return PclZip::errorCode();
     1577          }
     1578         
     1579          $v_result_list[$p_options_list[$i]] = true;
     1580          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1581        break;
     1582
     1583        case PCLZIP_OPT_EXTRACT_DIR_RESTRICTION :
     1584          // ----- Check the number of parameters
     1585          if (($i+1) >= $p_size) {
     1586            // ----- Error log
     1587            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1588
     1589            // ----- Return
     1590            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1591            return PclZip::errorCode();
     1592          }
     1593
     1594          // ----- Get the value
     1595          if (   is_string($p_options_list[$i+1])
     1596              && ($p_options_list[$i+1] != '')) {
     1597            $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
     1598            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1599            $i++;
     1600          }
     1601          else {
     1602            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." set with an empty value is ignored.");
     1603          }
     1604        break;
     1605
     1606        // ----- Look for options that request an array of string for value
     1607        case PCLZIP_OPT_BY_NAME :
     1608          // ----- Check the number of parameters
     1609          if (($i+1) >= $p_size) {
     1610            // ----- Error log
     1611            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1612
     1613            // ----- Return
     1614            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1615            return PclZip::errorCode();
     1616          }
     1617
     1618          // ----- Get the value
     1619          if (is_string($p_options_list[$i+1])) {
     1620              $v_result_list[$p_options_list[$i]][0] = $p_options_list[$i+1];
     1621          }
     1622          else if (is_array($p_options_list[$i+1])) {
     1623              $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
     1624          }
     1625          else {
     1626            // ----- Error log
     1627            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1628
     1629            // ----- Return
     1630            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1631            return PclZip::errorCode();
     1632          }
     1633          ////--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1634          $i++;
     1635        break;
     1636
     1637        // ----- Look for options that request an EREG or PREG expression
     1638        case PCLZIP_OPT_BY_EREG :
     1639        case PCLZIP_OPT_BY_PREG :
     1640        //case PCLZIP_OPT_CRYPT :
     1641          // ----- Check the number of parameters
     1642          if (($i+1) >= $p_size) {
     1643            // ----- Error log
     1644            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1645
     1646            // ----- Return
     1647            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1648            return PclZip::errorCode();
     1649          }
     1650
     1651          // ----- Get the value
     1652          if (is_string($p_options_list[$i+1])) {
     1653              $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
     1654          }
     1655          else {
     1656            // ----- Error log
     1657            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1658
     1659            // ----- Return
     1660            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1661            return PclZip::errorCode();
     1662          }
     1663          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1664          $i++;
     1665        break;
     1666
     1667        // ----- Look for options that takes a string
     1668        case PCLZIP_OPT_COMMENT :
     1669        case PCLZIP_OPT_ADD_COMMENT :
     1670        case PCLZIP_OPT_PREPEND_COMMENT :
     1671          // ----- Check the number of parameters
     1672          if (($i+1) >= $p_size) {
     1673            // ----- Error log
     1674            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
     1675                                 "Missing parameter value for option '"
    15911676                                 .PclZipUtilOptionText($p_options_list[$i])
    15921677                                 ."'");
    15931678
    1594             // ----- Return
    1595             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1596             return PclZip::errorCode();
    1597           }
    1598 
    1599           // ----- Get the value
    1600           if (is_string($p_options_list[$i+1])) {
    1601               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1602           }
    1603           else {
    1604             // ----- Error log
    1605             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
    1606                                 "Wrong parameter value for option '"
     1679            // ----- Return
     1680            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1681            return PclZip::errorCode();
     1682          }
     1683
     1684          // ----- Get the value
     1685          if (is_string($p_options_list[$i+1])) {
     1686              $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
     1687          }
     1688          else {
     1689            // ----- Error log
     1690            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
     1691                                "Wrong parameter value for option '"
    16071692                                 .PclZipUtilOptionText($p_options_list[$i])
    16081693                                 ."'");
    16091694
    1610             // ----- Return
    1611             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1612             return PclZip::errorCode();
    1613           }
    1614           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    1615           $i++;
    1616         break;
    1617 
    1618         // ----- Look for options that request an array of index
    1619         case PCLZIP_OPT_BY_INDEX :
    1620           // ----- Check the number of parameters
    1621           if (($i+1) >= $p_size) {
    1622             // ----- Error log
    1623             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1624 
    1625             // ----- Return
    1626             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1627             return PclZip::errorCode();
    1628           }
    1629 
    1630           // ----- Get the value
    1631           $v_work_list = array();
    1632           if (is_string($p_options_list[$i+1])) {
    1633               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is a string '".$p_options_list[$i+1]."'");
    1634 
    1635               // ----- Remove spaces
    1636               $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');
    1637 
    1638               // ----- Parse items
    1639               $v_work_list = explode(",", $p_options_list[$i+1]);
    1640           }
    1641           else if (is_integer($p_options_list[$i+1])) {
    1642               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is an integer '".$p_options_list[$i+1]."'");
    1643               $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];
    1644           }
    1645           else if (is_array($p_options_list[$i+1])) {
    1646               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is an array");
    1647               $v_work_list = $p_options_list[$i+1];
    1648           }
    1649           else {
    1650             // ----- Error log
    1651             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1652 
    1653             // ----- Return
    1654             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1655             return PclZip::errorCode();
    1656           }
    1657 
    1658           // ----- Reduce the index list
    1659           // each index item in the list must be a couple with a start and
    1660           // an end value : [0,3], [5-5], [8-10], ...
    1661           // ----- Check the format of each item
    1662           $v_sort_flag=false;
    1663           $v_sort_value=0;
    1664           for ($j=0; $j<sizeof($v_work_list); $j++) {
    1665               // ----- Explode the item
    1666               $v_item_list = explode("-", $v_work_list[$j]);
    1667               $v_size_item_list = sizeof($v_item_list);
    1668 
    1669               // ----- TBC : Here we might check that each item is a
    1670               // real integer ...
    1671 
    1672               // ----- Look for single value
    1673               if ($v_size_item_list == 1) {
    1674                   // ----- Set the option value
    1675                   $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
    1676                   $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[0];
    1677               }
    1678               elseif ($v_size_item_list == 2) {
    1679                   // ----- Set the option value
    1680                   $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
    1681                   $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[1];
    1682               }
    1683               else {
    1684                   // ----- Error log
    1685                   PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1686 
    1687                   // ----- Return
    1688                   //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1689                   return PclZip::errorCode();
    1690               }
    1691 
    1692               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extracted index item = [".$v_result_list[$p_options_list[$i]][$j]['start'].",".$v_result_list[$p_options_list[$i]][$j]['end']."]");
    1693 
    1694               // ----- Look for list sort
    1695               if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
    1696                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The list should be sorted ...");
    1697                   $v_sort_flag=true;
    1698 
    1699                   // ----- TBC : An automatic sort should be writen ...
    1700                   // ----- Error log
    1701                   PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1702 
    1703                   // ----- Return
    1704                   //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1705                   return PclZip::errorCode();
    1706               }
    1707               $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
    1708           }
    1709 
    1710           // ----- Sort the items
    1711           if ($v_sort_flag) {
    1712               // TBC : To Be Completed
    1713               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "List sorting is not yet write ...");
    1714           }
    1715 
    1716           // ----- Next option
    1717           $i++;
    1718         break;
    1719 
    1720         // ----- Look for options that request no value
    1721         case PCLZIP_OPT_REMOVE_ALL_PATH :
    1722         case PCLZIP_OPT_EXTRACT_AS_STRING :
    1723         case PCLZIP_OPT_NO_COMPRESSION :
    1724         case PCLZIP_OPT_EXTRACT_IN_OUTPUT :
    1725         case PCLZIP_OPT_REPLACE_NEWER :
    1726         case PCLZIP_OPT_STOP_ON_ERROR :
    1727           $v_result_list[$p_options_list[$i]] = true;
    1728           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    1729         break;
    1730 
    1731         // ----- Look for options that request an octal value
    1732         case PCLZIP_OPT_SET_CHMOD :
    1733           // ----- Check the number of parameters
    1734           if (($i+1) >= $p_size) {
    1735             // ----- Error log
    1736             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1737 
    1738             // ----- Return
    1739             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1740             return PclZip::errorCode();
    1741           }
    1742 
    1743           // ----- Get the value
    1744           $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1745           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    1746           $i++;
    1747         break;
    1748 
    1749         // ----- Look for options that request a call-back
    1750         case PCLZIP_CB_PRE_EXTRACT :
    1751         case PCLZIP_CB_POST_EXTRACT :
    1752         case PCLZIP_CB_PRE_ADD :
    1753         case PCLZIP_CB_POST_ADD :
    1754         /* for futur use
    1755         case PCLZIP_CB_PRE_DELETE :
    1756         case PCLZIP_CB_POST_DELETE :
    1757         case PCLZIP_CB_PRE_LIST :
    1758         case PCLZIP_CB_POST_LIST :
    1759         */
    1760           // ----- Check the number of parameters
    1761           if (($i+1) >= $p_size) {
    1762             // ----- Error log
    1763             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1764 
    1765             // ----- Return
    1766             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1767             return PclZip::errorCode();
    1768           }
    1769 
    1770           // ----- Get the value
    1771           $v_function_name = $p_options_list[$i+1];
    1772           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "call-back ".PclZipUtilOptionText($p_options_list[$i])." = '".$v_function_name."'");
    1773 
    1774           // ----- Check that the value is a valid existing function
    1775           if (!function_exists($v_function_name)) {
    1776             // ----- Error log
    1777             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Function '".$v_function_name."()' is not an existing function for option '".PclZipUtilOptionText($p_options_list[$i])."'");
    1778 
    1779             // ----- Return
    1780             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1781             return PclZip::errorCode();
    1782           }
    1783 
    1784           // ----- Set the attribute
    1785           $v_result_list[$p_options_list[$i]] = $v_function_name;
    1786           $i++;
    1787         break;
    1788 
    1789         default :
    1790           // ----- Error log
    1791           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
    1792                                "Unknown parameter '"
     1695            // ----- Return
     1696            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1697            return PclZip::errorCode();
     1698          }
     1699          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1700          $i++;
     1701        break;
     1702
     1703        // ----- Look for options that request an array of index
     1704        case PCLZIP_OPT_BY_INDEX :
     1705          // ----- Check the number of parameters
     1706          if (($i+1) >= $p_size) {
     1707            // ----- Error log
     1708            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1709
     1710            // ----- Return
     1711            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1712            return PclZip::errorCode();
     1713          }
     1714
     1715          // ----- Get the value
     1716          $v_work_list = array();
     1717          if (is_string($p_options_list[$i+1])) {
     1718              //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is a string '".$p_options_list[$i+1]."'");
     1719
     1720              // ----- Remove spaces
     1721              $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');
     1722
     1723              // ----- Parse items
     1724              $v_work_list = explode(",", $p_options_list[$i+1]);
     1725          }
     1726          else if (is_integer($p_options_list[$i+1])) {
     1727              //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is an integer '".$p_options_list[$i+1]."'");
     1728              $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];
     1729          }
     1730          else if (is_array($p_options_list[$i+1])) {
     1731              //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is an array");
     1732              $v_work_list = $p_options_list[$i+1];
     1733          }
     1734          else {
     1735            // ----- Error log
     1736            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1737
     1738            // ----- Return
     1739            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1740            return PclZip::errorCode();
     1741          }
     1742         
     1743          // ----- Reduce the index list
     1744          // each index item in the list must be a couple with a start and
     1745          // an end value : [0,3], [5-5], [8-10], ...
     1746          // ----- Check the format of each item
     1747          $v_sort_flag=false;
     1748          $v_sort_value=0;
     1749          for ($j=0; $j<sizeof($v_work_list); $j++) {
     1750              // ----- Explode the item
     1751              $v_item_list = explode("-", $v_work_list[$j]);
     1752              $v_size_item_list = sizeof($v_item_list);
     1753             
     1754              // ----- TBC : Here we might check that each item is a
     1755              // real integer ...
     1756             
     1757              // ----- Look for single value
     1758              if ($v_size_item_list == 1) {
     1759                  // ----- Set the option value
     1760                  $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
     1761                  $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[0];
     1762              }
     1763              elseif ($v_size_item_list == 2) {
     1764                  // ----- Set the option value
     1765                  $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
     1766                  $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[1];
     1767              }
     1768              else {
     1769                  // ----- Error log
     1770                  PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1771
     1772                  // ----- Return
     1773                  //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1774                  return PclZip::errorCode();
     1775              }
     1776
     1777              //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extracted index item = [".$v_result_list[$p_options_list[$i]][$j]['start'].",".$v_result_list[$p_options_list[$i]][$j]['end']."]");
     1778
     1779              // ----- Look for list sort
     1780              if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
     1781                  //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The list should be sorted ...");
     1782                  $v_sort_flag=true;
     1783
     1784                  // ----- TBC : An automatic sort should be writen ...
     1785                  // ----- Error log
     1786                  PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1787
     1788                  // ----- Return
     1789                  //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1790                  return PclZip::errorCode();
     1791              }
     1792              $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
     1793          }
     1794         
     1795          // ----- Sort the items
     1796          if ($v_sort_flag) {
     1797              // TBC : To Be Completed
     1798              //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "List sorting is not yet write ...");
     1799          }
     1800
     1801          // ----- Next option
     1802          $i++;
     1803        break;
     1804
     1805        // ----- Look for options that request no value
     1806        case PCLZIP_OPT_REMOVE_ALL_PATH :
     1807        case PCLZIP_OPT_EXTRACT_AS_STRING :
     1808        case PCLZIP_OPT_NO_COMPRESSION :
     1809        case PCLZIP_OPT_EXTRACT_IN_OUTPUT :
     1810        case PCLZIP_OPT_REPLACE_NEWER :
     1811        case PCLZIP_OPT_STOP_ON_ERROR :
     1812          $v_result_list[$p_options_list[$i]] = true;
     1813          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1814        break;
     1815
     1816        // ----- Look for options that request an octal value
     1817        case PCLZIP_OPT_SET_CHMOD :
     1818          // ----- Check the number of parameters
     1819          if (($i+1) >= $p_size) {
     1820            // ----- Error log
     1821            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1822
     1823            // ----- Return
     1824            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1825            return PclZip::errorCode();
     1826          }
     1827
     1828          // ----- Get the value
     1829          $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
     1830          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1831          $i++;
     1832        break;
     1833
     1834        // ----- Look for options that request a call-back
     1835        case PCLZIP_CB_PRE_EXTRACT :
     1836        case PCLZIP_CB_POST_EXTRACT :
     1837        case PCLZIP_CB_PRE_ADD :
     1838        case PCLZIP_CB_POST_ADD :
     1839        /* for futur use
     1840        case PCLZIP_CB_PRE_DELETE :
     1841        case PCLZIP_CB_POST_DELETE :
     1842        case PCLZIP_CB_PRE_LIST :
     1843        case PCLZIP_CB_POST_LIST :
     1844        */
     1845          // ----- Check the number of parameters
     1846          if (($i+1) >= $p_size) {
     1847            // ----- Error log
     1848            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1849
     1850            // ----- Return
     1851            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1852            return PclZip::errorCode();
     1853          }
     1854
     1855          // ----- Get the value
     1856          $v_function_name = $p_options_list[$i+1];
     1857          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "call-back ".PclZipUtilOptionText($p_options_list[$i])." = '".$v_function_name."'");
     1858
     1859          // ----- Check that the value is a valid existing function
     1860          if (!function_exists($v_function_name)) {
     1861            // ----- Error log
     1862            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Function '".$v_function_name."()' is not an existing function for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1863
     1864            // ----- Return
     1865            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1866            return PclZip::errorCode();
     1867          }
     1868
     1869          // ----- Set the attribute
     1870          $v_result_list[$p_options_list[$i]] = $v_function_name;
     1871          $i++;
     1872        break;
     1873
     1874        default :
     1875          // ----- Error log
     1876          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     1877                               "Unknown parameter '"
    17931878                               .$p_options_list[$i]."'");
    17941879
    1795           // ----- Return
    1796           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1797           return PclZip::errorCode();
    1798       }
    1799 
    1800       // ----- Next options
    1801       $i++;
    1802     }
    1803 
    1804     // ----- Look for mandatory options
    1805     if ($v_requested_options !== false) {
    1806       for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
    1807         // ----- Look for mandatory option
    1808         if ($v_requested_options[$key] == 'mandatory') {
    1809           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Detect a mandatory option : ".PclZipUtilOptionText($key)."(".$key.")");
    1810           // ----- Look if present
    1811           if (!isset($v_result_list[$key])) {
    1812             // ----- Error log
    1813             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
    1814 
    1815             // ----- Return
    1816             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1817             return PclZip::errorCode();
    1818           }
    1819         }
    1820       }
    1821     }
    1822 
    1823     // ----- Return
    1824     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    1825     return $v_result;
     1880          // ----- Return
     1881          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1882          return PclZip::errorCode();
     1883      }
     1884
     1885      // ----- Next options
     1886      $i++;
     1887    }
     1888
     1889    // ----- Look for mandatory options
     1890    if ($v_requested_options !== false) {
     1891      for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
     1892        // ----- Look for mandatory option
     1893        if ($v_requested_options[$key] == 'mandatory') {
     1894          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Detect a mandatory option : ".PclZipUtilOptionText($key)."(".$key.")");
     1895          // ----- Look if present
     1896          if (!isset($v_result_list[$key])) {
     1897            // ----- Error log
     1898            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
     1899
     1900            // ----- Return
     1901            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1902            return PclZip::errorCode();
     1903          }
     1904        }
     1905      }
     1906    }
     1907   
     1908    // ----- Look for default values
     1909    if (!isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
     1910      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Calculate auto threshold");
     1911     
     1912    }
     1913
     1914    // ----- Return
     1915    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     1916    return $v_result;
     1917  }
     1918  // --------------------------------------------------------------------------------
     1919
     1920  // --------------------------------------------------------------------------------
     1921  // Function : privOptionDefaultThreshold()
     1922  // Description :
     1923  // Parameters :
     1924  // Return Values :
     1925  // --------------------------------------------------------------------------------
     1926  function privOptionDefaultThreshold(&$p_options)
     1927  {
     1928    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privOptionDefaultThreshold", "");
     1929    $v_result=1;
     1930   
     1931    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Create an auto-threshold for use of temporay files");
     1932    // ----- Get 'memory_limit' configuration value
     1933    $v_memory_limit = ini_get('memory_limit');
     1934    $v_memory_limit = trim($v_memory_limit);
     1935    $last = strtolower(substr($v_memory_limit, -1));
     1936 
     1937    if($last == 'g')
     1938        //$v_memory_limit = $v_memory_limit*1024*1024*1024;
     1939        $v_memory_limit = $v_memory_limit*1073741824;
     1940    if($last == 'm')
     1941        //$v_memory_limit = $v_memory_limit*1024*1024;
     1942        $v_memory_limit = $v_memory_limit*1048576;
     1943    if($last == 'k')
     1944        $v_memory_limit = $v_memory_limit*1024;
     1945           
     1946    $p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD] = floor($v_memory_limit/2);
     1947   
     1948    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Threshold value is : ".$p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD]." bytes");
     1949
     1950    // ----- Sanity check : No threshold if value lower than 1M
     1951    if ($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD] < 1048576) {
     1952      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Unset the threshold (value ".$p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD].") because under 1Mo sanity check)");
     1953      unset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD]);
     1954    }
     1955         
     1956    // ----- Return
     1957    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     1958    return $v_result;
    18261959  }
    18271960  // --------------------------------------------------------------------------------
     
    18371970  function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)
    18381971  {
    1839     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privFileDescrParseAtt", "");
    1840     $v_result=1;
    1841 
    1842     // ----- For each file in the list check the attributes
    1843     foreach ($p_file_list as $v_key => $v_value) {
    1844 
    1845       // ----- Check if the option is supported
    1846       if (!isset($v_requested_options[$v_key])) {
    1847         // ----- Error log
    1848         PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");
    1849 
    1850         // ----- Return
    1851         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1852         return PclZip::errorCode();
    1853       }
    1854 
    1855       // ----- Look for attribute
    1856       switch ($v_key) {
    1857         case PCLZIP_ATT_FILE_NAME :
    1858           if (!is_string($v_value)) {
    1859             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
    1860             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1861             return PclZip::errorCode();
    1862           }
    1863 
    1864           $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
    1865           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
    1866 
    1867           if ($p_filedescr['filename'] == '') {
    1868             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
    1869             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1870             return PclZip::errorCode();
    1871           }
    1872 
    1873         break;
    1874 
    1875         case PCLZIP_ATT_FILE_NEW_SHORT_NAME :
    1876           if (!is_string($v_value)) {
    1877             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
    1878             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1879             return PclZip::errorCode();
    1880           }
    1881 
    1882           $p_filedescr['new_short_name'] = PclZipUtilPathReduction($v_value);
    1883           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
    1884 
    1885           if ($p_filedescr['new_short_name'] == '') {
    1886             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");
    1887             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1888             return PclZip::errorCode();
    1889           }
    1890         break;
    1891 
    1892         case PCLZIP_ATT_FILE_NEW_FULL_NAME :
    1893           if (!is_string($v_value)) {
    1894             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
    1895             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1896             return PclZip::errorCode();
    1897           }
    1898 
    1899           $p_filedescr['new_full_name'] = PclZipUtilPathReduction($v_value);
    1900           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
    1901 
    1902           if ($p_filedescr['new_full_name'] == '') {
    1903             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");
    1904             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1905             return PclZip::errorCode();
    1906           }
    1907         break;
    1908 
    1909         default :
    1910           // ----- Error log
    1911           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
    1912                                    "Unknown parameter '".$v_key."'");
    1913 
    1914           // ----- Return
    1915           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1916           return PclZip::errorCode();
    1917       }
    1918 
    1919       // ----- Look for mandatory options
    1920       if ($v_requested_options !== false) {
    1921         for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
    1922           // ----- Look for mandatory option
    1923           if ($v_requested_options[$key] == 'mandatory') {
    1924             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Detect a mandatory option : ".PclZipUtilOptionText($key)."(".$key.")");
    1925             // ----- Look if present
    1926             if (!isset($p_file_list[$key])) {
    1927               PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
    1928               //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1929               return PclZip::errorCode();
    1930             }
    1931           }
    1932         }
    1933       }
    1934 
    1935     // end foreach
    1936     }
    1937 
    1938     // ----- Return
    1939     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    1940     return $v_result;
     1972    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privFileDescrParseAtt", "");
     1973    $v_result=1;
     1974   
     1975    // ----- For each file in the list check the attributes
     1976    foreach ($p_file_list as $v_key => $v_value) {
     1977   
     1978      // ----- Check if the option is supported
     1979      if (!isset($v_requested_options[$v_key])) {
     1980        // ----- Error log
     1981        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");
     1982
     1983        // ----- Return
     1984        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1985        return PclZip::errorCode();
     1986      }
     1987
     1988      // ----- Look for attribute
     1989      switch ($v_key) {
     1990        case PCLZIP_ATT_FILE_NAME :
     1991          if (!is_string($v_value)) {
     1992            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1993            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     1994            return PclZip::errorCode();
     1995          }
     1996
     1997          $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
     1998          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
     1999         
     2000          if ($p_filedescr['filename'] == '') {
     2001            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
     2002            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2003            return PclZip::errorCode();
     2004          }
     2005
     2006        break;
     2007
     2008        case PCLZIP_ATT_FILE_NEW_SHORT_NAME :
     2009          if (!is_string($v_value)) {
     2010            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     2011            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2012            return PclZip::errorCode();
     2013          }
     2014
     2015          $p_filedescr['new_short_name'] = PclZipUtilPathReduction($v_value);
     2016          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
     2017
     2018          if ($p_filedescr['new_short_name'] == '') {
     2019            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");
     2020            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2021            return PclZip::errorCode();
     2022          }
     2023        break;
     2024
     2025        case PCLZIP_ATT_FILE_NEW_FULL_NAME :
     2026          if (!is_string($v_value)) {
     2027            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     2028            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2029            return PclZip::errorCode();
     2030          }
     2031
     2032          $p_filedescr['new_full_name'] = PclZipUtilPathReduction($v_value);
     2033          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
     2034
     2035          if ($p_filedescr['new_full_name'] == '') {
     2036            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");
     2037            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2038            return PclZip::errorCode();
     2039          }
     2040        break;
     2041
     2042        // ----- Look for options that takes a string
     2043        case PCLZIP_ATT_FILE_COMMENT :
     2044          if (!is_string($v_value)) {
     2045            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     2046            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2047            return PclZip::errorCode();
     2048          }
     2049
     2050          $p_filedescr['comment'] = $v_value;
     2051          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
     2052        break;
     2053
     2054        case PCLZIP_ATT_FILE_MTIME :
     2055          if (!is_integer($v_value)) {
     2056            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". Integer expected for attribute '".PclZipUtilOptionText($v_key)."'");
     2057            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2058            return PclZip::errorCode();
     2059          }
     2060
     2061          $p_filedescr['mtime'] = $v_value;
     2062          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
     2063        break;
     2064
     2065        case PCLZIP_ATT_FILE_CONTENT :
     2066          $p_filedescr['content'] = $v_value;
     2067          ////--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
     2068        break;
     2069
     2070        default :
     2071          // ----- Error log
     2072          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
     2073                                   "Unknown parameter '".$v_key."'");
     2074
     2075          // ----- Return
     2076          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2077          return PclZip::errorCode();
     2078      }
     2079
     2080      // ----- Look for mandatory options
     2081      if ($v_requested_options !== false) {
     2082        for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
     2083          // ----- Look for mandatory option
     2084          if ($v_requested_options[$key] == 'mandatory') {
     2085            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Detect a mandatory option : ".PclZipUtilOptionText($key)."(".$key.")");
     2086            // ----- Look if present
     2087            if (!isset($p_file_list[$key])) {
     2088              PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
     2089              //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2090              return PclZip::errorCode();
     2091            }
     2092          }
     2093        }
     2094      }
     2095   
     2096    // end foreach
     2097    }
     2098   
     2099    // ----- Return
     2100    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2101    return $v_result;
    19412102  }
    19422103  // --------------------------------------------------------------------------------
     
    19452106  // Function : privFileDescrExpand()
    19462107  // Description :
     2108  //   This method look for each item of the list to see if its a file, a folder
     2109  //   or a string to be added as file. For any other type of files (link, other)
     2110  //   just ignore the item.
     2111  //   Then prepare the information that will be stored for that file.
     2112  //   When its a folder, expand the folder with all the files that are in that
     2113  //   folder (recursively).
    19472114  // Parameters :
    19482115  // Return Values :
     
    19522119  function privFileDescrExpand(&$p_filedescr_list, &$p_options)
    19532120  {
    1954     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privFileDescrExpand", "");
    1955     $v_result=1;
    1956 
    1957     // ----- Create a result list
    1958     $v_result_list = array();
    1959 
    1960     // ----- Look each entry
    1961     for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
    1962       // ----- Get filedescr
    1963       $v_descr = $p_filedescr_list[$i];
    1964 
    1965       // ----- Reduce the filename
    1966       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filedescr before reduction :'".$v_descr['filename']."'");
    1967       $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename']);
    1968       $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
    1969       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filedescr after reduction :'".$v_descr['filename']."'");
    1970 
    1971       // ----- Get type of descr
    1972       if (!file_exists($v_descr['filename'])) {
    1973         // ----- Error log
    1974         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$v_descr['filename']."' does not exists");
    1975         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exists");
    1976 
    1977         // ----- Return
    1978         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    1979         return PclZip::errorCode();
    1980       }
    1981       if (@is_file($v_descr['filename'])) {
    1982         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "This is a file");
    1983         $v_descr['type'] = 'file';
    1984       }
    1985       else if (@is_dir($v_descr['filename'])) {
    1986         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "This is a folder");
    1987         $v_descr['type'] = 'folder';
    1988       }
    1989       else if (@is_link($v_descr['filename'])) {
    1990         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Unsupported file type : link");
    1991         // skip
    1992         continue;
    1993       }
    1994       else {
    1995         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Unsupported file type : unknown type");
    1996         // skip
    1997         continue;
    1998       }
    1999 
    2000       // ----- Calculate the stored filename
    2001       $this->privCalculateStoredFilename($v_descr, $p_options);
    2002 
    2003       // ----- Add the descriptor in result list
    2004       $v_result_list[sizeof($v_result_list)] = $v_descr;
    2005 
    2006       // ----- Look for folder
    2007       if ($v_descr['type'] == 'folder') {
    2008         // ----- List of items in folder
    2009         $v_dirlist_descr = array();
    2010         $v_dirlist_nb = 0;
    2011         if ($v_folder_handler = @opendir($v_descr['filename'])) {
    2012           while (($v_item_handler = @readdir($v_folder_handler)) !== false) {
    2013             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Looking for '".$v_item_handler."' in the directory");
    2014 
    2015             // ----- Skip '.' and '..'
    2016             if (($v_item_handler == '.') || ($v_item_handler == '..')) {
    2017                 continue;
    2018             }
    2019 
    2020             // ----- Compose the full filename
    2021             $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
    2022 
    2023             // ----- Look for different stored filename
    2024             // Because the name of the folder was changed, the name of the
    2025             // files/sub-folders also change
    2026             if ($v_descr['stored_filename'] != $v_descr['filename']) {
    2027               $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
    2028             }
    2029 
    2030             $v_dirlist_nb++;
    2031           }
    2032         }
    2033         else {
    2034           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to open dir '".$v_descr['filename']."' in read mode. Skipped.");
    2035           // TBC : unable to open folder in read mode
    2036         }
    2037 
    2038         // ----- Expand each element of the list
    2039         if ($v_dirlist_nb != 0) {
    2040           // ----- Expand
    2041           if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {
    2042             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2043             return $v_result;
    2044           }
    2045 
    2046           // ----- Concat the resulting list
    2047           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Merging result list (size '".sizeof($v_result_list)."') with dirlist (size '".sizeof($v_dirlist_descr)."')");
    2048           $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
    2049           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "merged result list is size '".sizeof($v_result_list)."'");
    2050         }
    2051         else {
    2052           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Nothing in this folder to expand.");
    2053         }
    2054 
    2055         // ----- Free local array
    2056         unset($v_dirlist_descr);
    2057       }
    2058     }
    2059 
    2060     // ----- Get the result list
    2061     $p_filedescr_list = $v_result_list;
    2062 
    2063     // ----- Return
    2064     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2065     return $v_result;
     2121    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privFileDescrExpand", "");
     2122    $v_result=1;
     2123   
     2124    // ----- Create a result list
     2125    $v_result_list = array();
     2126   
     2127    // ----- Look each entry
     2128    for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
     2129      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Looking for file ".$i.".");
     2130     
     2131      // ----- Get filedescr
     2132      $v_descr = $p_filedescr_list[$i];
     2133     
     2134      // ----- Reduce the filename
     2135      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filedescr before reduction :'".$v_descr['filename']."'");
     2136      $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
     2137      $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
     2138      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filedescr after reduction :'".$v_descr['filename']."'");
     2139     
     2140      // ----- Look for real file or folder
     2141      if (file_exists($v_descr['filename'])) {
     2142        if (@is_file($v_descr['filename'])) {
     2143          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "This is a file");
     2144          $v_descr['type'] = 'file';
     2145        }
     2146        else if (@is_dir($v_descr['filename'])) {
     2147          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "This is a folder");
     2148          $v_descr['type'] = 'folder';
     2149        }
     2150        else if (@is_link($v_descr['filename'])) {
     2151          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Unsupported file type : link");
     2152          // skip
     2153          continue;
     2154        }
     2155        else {
     2156          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Unsupported file type : unknown type");
     2157          // skip
     2158          continue;
     2159        }
     2160      }
     2161     
     2162      // ----- Look for string added as file
     2163      else if (isset($v_descr['content'])) {
     2164        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "This is a string added as a file");
     2165        $v_descr['type'] = 'virtual_file';
     2166      }
     2167     
     2168      // ----- Missing file
     2169      else {
     2170        // ----- Error log
     2171        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$v_descr['filename']."' does not exist");
     2172        PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exist");
     2173
     2174        // ----- Return
     2175        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2176        return PclZip::errorCode();
     2177      }
     2178     
     2179      // ----- Calculate the stored filename
     2180      $this->privCalculateStoredFilename($v_descr, $p_options);
     2181     
     2182      // ----- Add the descriptor in result list
     2183      $v_result_list[sizeof($v_result_list)] = $v_descr;
     2184     
     2185      // ----- Look for folder
     2186      if ($v_descr['type'] == 'folder') {
     2187        // ----- List of items in folder
     2188        $v_dirlist_descr = array();
     2189        $v_dirlist_nb = 0;
     2190        if ($v_folder_handler = @opendir($v_descr['filename'])) {
     2191          while (($v_item_handler = @readdir($v_folder_handler)) !== false) {
     2192            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Looking for '".$v_item_handler."' in the directory");
     2193
     2194            // ----- Skip '.' and '..'
     2195            if (($v_item_handler == '.') || ($v_item_handler == '..')) {
     2196                continue;
     2197            }
     2198           
     2199            // ----- Compose the full filename
     2200            $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
     2201           
     2202            // ----- Look for different stored filename
     2203            // Because the name of the folder was changed, the name of the
     2204            // files/sub-folders also change
     2205            if ($v_descr['stored_filename'] != $v_descr['filename']) {
     2206              if ($v_descr['stored_filename'] != '') {
     2207                $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
     2208              }
     2209              else {
     2210                $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_item_handler;
     2211              }
     2212            }
     2213     
     2214            $v_dirlist_nb++;
     2215          }
     2216         
     2217          @closedir($v_folder_handler);
     2218        }
     2219        else {
     2220          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to open dir '".$v_descr['filename']."' in read mode. Skipped.");
     2221          // TBC : unable to open folder in read mode
     2222        }
     2223       
     2224        // ----- Expand each element of the list
     2225        if ($v_dirlist_nb != 0) {
     2226          // ----- Expand
     2227          if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {
     2228            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2229            return $v_result;
     2230          }
     2231         
     2232          // ----- Concat the resulting list
     2233          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Merging result list (size '".sizeof($v_result_list)."') with dirlist (size '".sizeof($v_dirlist_descr)."')");
     2234          $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
     2235          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "merged result list is size '".sizeof($v_result_list)."'");
     2236        }
     2237        else {
     2238          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Nothing in this folder to expand.");
     2239        }
     2240         
     2241        // ----- Free local array
     2242        unset($v_dirlist_descr);
     2243      }
     2244    }
     2245   
     2246    // ----- Get the result list
     2247    $p_filedescr_list = $v_result_list;
     2248
     2249    // ----- Return
     2250    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2251    return $v_result;
    20662252  }
    20672253  // --------------------------------------------------------------------------------
     
    20752261  function privCreate($p_filedescr_list, &$p_result_list, &$p_options)
    20762262  {
    2077     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCreate", "list");
    2078     $v_result=1;
    2079     $v_list_detail = array();
    2080 
    2081     // ----- Magic quotes trick
    2082     $this->privDisableMagicQuotes();
    2083 
    2084     // ----- Open the file in write mode
    2085     if (($v_result = $this->privOpenFd('wb')) != 1)
    2086     {
    2087       // ----- Return
    2088       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2089       return $v_result;
    2090     }
    2091 
    2092     // ----- Add the list of files
    2093     $v_result = $this->privAddList($p_filedescr_list, $p_result_list, $p_options);
    2094 
    2095     // ----- Close
    2096     $this->privCloseFd();
    2097 
    2098     // ----- Magic quotes trick
    2099     $this->privSwapBackMagicQuotes();
    2100 
    2101     // ----- Return
    2102     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2103     return $v_result;
     2263    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCreate", "list");
     2264    $v_result=1;
     2265    $v_list_detail = array();
     2266   
     2267    // ----- Magic quotes trick
     2268    $this->privDisableMagicQuotes();
     2269
     2270    // ----- Open the file in write mode
     2271    if (($v_result = $this->privOpenFd('wb')) != 1)
     2272    {
     2273      // ----- Return
     2274      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2275      return $v_result;
     2276    }
     2277
     2278    // ----- Add the list of files
     2279    $v_result = $this->privAddList($p_filedescr_list, $p_result_list, $p_options);
     2280
     2281    // ----- Close
     2282    $this->privCloseFd();
     2283
     2284    // ----- Magic quotes trick
     2285    $this->privSwapBackMagicQuotes();
     2286
     2287    // ----- Return
     2288    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2289    return $v_result;
    21042290  }
    21052291  // --------------------------------------------------------------------------------
     
    21132299  function privAdd($p_filedescr_list, &$p_result_list, &$p_options)
    21142300  {
    2115     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAdd", "list");
    2116     $v_result=1;
    2117     $v_list_detail = array();
    2118 
    2119     // ----- Look if the archive exists or is empty
    2120     if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0))
    2121     {
    2122       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Archive does not exist, or is empty, create it.");
    2123 
    2124       // ----- Do a create
    2125       $v_result = $this->privCreate($p_filedescr_list, $p_result_list, $p_options);
    2126 
    2127       // ----- Return
    2128       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2129       return $v_result;
    2130     }
    2131     // ----- Magic quotes trick
    2132     $this->privDisableMagicQuotes();
    2133 
    2134     // ----- Open the zip file
    2135     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    2136     if (($v_result=$this->privOpenFd('rb')) != 1)
    2137     {
    2138       // ----- Magic quotes trick
    2139       $this->privSwapBackMagicQuotes();
    2140 
    2141       // ----- Return
    2142       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2143       return $v_result;
    2144     }
    2145 
    2146     // ----- Read the central directory informations
    2147     $v_central_dir = array();
    2148     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
    2149     {
    2150       $this->privCloseFd();
    2151       $this->privSwapBackMagicQuotes();
    2152       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2153       return $v_result;
    2154     }
    2155 
    2156     // ----- Go to beginning of File
    2157     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
    2158     @rewind($this->zip_fd);
    2159     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
    2160 
    2161     // ----- Creates a temporay file
    2162     $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
    2163 
    2164     // ----- Open the temporary file in write mode
    2165     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    2166     if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
    2167     {
    2168       $this->privCloseFd();
    2169       $this->privSwapBackMagicQuotes();
    2170 
    2171       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
    2172 
    2173       // ----- Return
    2174       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    2175       return PclZip::errorCode();
    2176     }
    2177 
    2178     // ----- Copy the files from the archive to the temporary file
    2179     // TBC : Here I should better append the file and go back to erase the central dir
    2180     $v_size = $v_central_dir['offset'];
    2181     while ($v_size != 0)
    2182     {
    2183       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    2184       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    2185       $v_buffer = fread($this->zip_fd, $v_read_size);
    2186       @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
    2187       $v_size -= $v_read_size;
    2188     }
    2189 
    2190     // ----- Swap the file descriptor
    2191     // Here is a trick : I swap the temporary fd with the zip fd, in order to use
    2192     // the following methods on the temporary fil and not the real archive
    2193     $v_swap = $this->zip_fd;
    2194     $this->zip_fd = $v_zip_temp_fd;
    2195     $v_zip_temp_fd = $v_swap;
    2196 
    2197     // ----- Add the files
    2198     $v_header_list = array();
    2199     if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
    2200     {
    2201       fclose($v_zip_temp_fd);
    2202       $this->privCloseFd();
    2203       @unlink($v_zip_temp_name);
    2204       $this->privSwapBackMagicQuotes();
    2205 
    2206       // ----- Return
    2207       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2208       return $v_result;
    2209     }
    2210 
    2211     // ----- Store the offset of the central dir
    2212     $v_offset = @ftell($this->zip_fd);
    2213     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "New offset of central dir : $v_offset");
    2214 
    2215     // ----- Copy the block of file headers from the old archive
    2216     $v_size = $v_central_dir['size'];
    2217     while ($v_size != 0)
    2218     {
    2219       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    2220       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    2221       $v_buffer = @fread($v_zip_temp_fd, $v_read_size);
    2222       @fwrite($this->zip_fd, $v_buffer, $v_read_size);
    2223       $v_size -= $v_read_size;
    2224     }
    2225 
    2226     // ----- Create the Central Dir files header
    2227     for ($i=0, $v_count=0; $i<sizeof($v_header_list); $i++)
    2228     {
    2229       // ----- Create the file header
    2230       if ($v_header_list[$i]['status'] == 'ok') {
    2231         if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
    2232           fclose($v_zip_temp_fd);
    2233           $this->privCloseFd();
    2234           @unlink($v_zip_temp_name);
    2235           $this->privSwapBackMagicQuotes();
    2236 
    2237           // ----- Return
    2238           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2239           return $v_result;
    2240         }
    2241         $v_count++;
    2242       }
    2243 
    2244       // ----- Transform the header to a 'usable' info
    2245       $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
    2246     }
    2247 
    2248     // ----- Zip file comment
    2249     $v_comment = $v_central_dir['comment'];
    2250     if (isset($p_options[PCLZIP_OPT_COMMENT])) {
    2251       $v_comment = $p_options[PCLZIP_OPT_COMMENT];
    2252     }
    2253     if (isset($p_options[PCLZIP_OPT_ADD_COMMENT])) {
    2254       $v_comment = $v_comment.$p_options[PCLZIP_OPT_ADD_COMMENT];
    2255     }
    2256     if (isset($p_options[PCLZIP_OPT_PREPEND_COMMENT])) {
    2257       $v_comment = $p_options[PCLZIP_OPT_PREPEND_COMMENT].$v_comment;
    2258     }
    2259 
    2260     // ----- Calculate the size of the central header
    2261     $v_size = @ftell($this->zip_fd)-$v_offset;
    2262 
    2263     // ----- Create the central dir footer
    2264     if (($v_result = $this->privWriteCentralHeader($v_count+$v_central_dir['entries'], $v_size, $v_offset, $v_comment)) != 1)
    2265     {
    2266       // ----- Reset the file list
    2267       unset($v_header_list);
    2268       $this->privSwapBackMagicQuotes();
    2269 
    2270       // ----- Return
    2271       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2272       return $v_result;
    2273     }
    2274 
    2275     // ----- Swap back the file descriptor
    2276     $v_swap = $this->zip_fd;
    2277     $this->zip_fd = $v_zip_temp_fd;
    2278     $v_zip_temp_fd = $v_swap;
    2279 
    2280     // ----- Close
    2281     $this->privCloseFd();
    2282 
    2283     // ----- Close the temporary file
    2284     @fclose($v_zip_temp_fd);
    2285 
    2286     // ----- Magic quotes trick
    2287     $this->privSwapBackMagicQuotes();
    2288 
    2289     // ----- Delete the zip file
    2290     // TBC : I should test the result ...
    2291     @unlink($this->zipname);
    2292 
    2293     // ----- Rename the temporary file
    2294     // TBC : I should test the result ...
    2295     //@rename($v_zip_temp_name, $this->zipname);
    2296     PclZipUtilRename($v_zip_temp_name, $this->zipname);
    2297 
    2298     // ----- Return
    2299     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2300     return $v_result;
     2301    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAdd", "list");
     2302    $v_result=1;
     2303    $v_list_detail = array();
     2304
     2305    // ----- Look if the archive exists or is empty
     2306    if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0))
     2307    {
     2308      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Archive does not exist, or is empty, create it.");
     2309
     2310      // ----- Do a create
     2311      $v_result = $this->privCreate($p_filedescr_list, $p_result_list, $p_options);
     2312
     2313      // ----- Return
     2314      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2315      return $v_result;
     2316    }
     2317    // ----- Magic quotes trick
     2318    $this->privDisableMagicQuotes();
     2319
     2320    // ----- Open the zip file
     2321    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
     2322    if (($v_result=$this->privOpenFd('rb')) != 1)
     2323    {
     2324      // ----- Magic quotes trick
     2325      $this->privSwapBackMagicQuotes();
     2326
     2327      // ----- Return
     2328      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2329      return $v_result;
     2330    }
     2331
     2332    // ----- Read the central directory informations
     2333    $v_central_dir = array();
     2334    if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
     2335    {
     2336      $this->privCloseFd();
     2337      $this->privSwapBackMagicQuotes();
     2338      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2339      return $v_result;
     2340    }
     2341
     2342    // ----- Go to beginning of File
     2343    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
     2344    @rewind($this->zip_fd);
     2345    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
     2346
     2347    // ----- Creates a temporay file
     2348    $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
     2349
     2350    // ----- Open the temporary file in write mode
     2351    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
     2352    if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
     2353    {
     2354      $this->privCloseFd();
     2355      $this->privSwapBackMagicQuotes();
     2356
     2357      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
     2358
     2359      // ----- Return
     2360      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2361      return PclZip::errorCode();
     2362    }
     2363
     2364    // ----- Copy the files from the archive to the temporary file
     2365    // TBC : Here I should better append the file and go back to erase the central dir
     2366    $v_size = $v_central_dir['offset'];
     2367    while ($v_size != 0)
     2368    {
     2369      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     2370      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
     2371      $v_buffer = fread($this->zip_fd, $v_read_size);
     2372      @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
     2373      $v_size -= $v_read_size;
     2374    }
     2375
     2376    // ----- Swap the file descriptor
     2377    // Here is a trick : I swap the temporary fd with the zip fd, in order to use
     2378    // the following methods on the temporary fil and not the real archive
     2379    $v_swap = $this->zip_fd;
     2380    $this->zip_fd = $v_zip_temp_fd;
     2381    $v_zip_temp_fd = $v_swap;
     2382
     2383    // ----- Add the files
     2384    $v_header_list = array();
     2385    if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
     2386    {
     2387      fclose($v_zip_temp_fd);
     2388      $this->privCloseFd();
     2389      @unlink($v_zip_temp_name);
     2390      $this->privSwapBackMagicQuotes();
     2391
     2392      // ----- Return
     2393      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2394      return $v_result;
     2395    }
     2396
     2397    // ----- Store the offset of the central dir
     2398    $v_offset = @ftell($this->zip_fd);
     2399    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "New offset of central dir : $v_offset");
     2400
     2401    // ----- Copy the block of file headers from the old archive
     2402    $v_size = $v_central_dir['size'];
     2403    while ($v_size != 0)
     2404    {
     2405      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     2406      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
     2407      $v_buffer = @fread($v_zip_temp_fd, $v_read_size);
     2408      @fwrite($this->zip_fd, $v_buffer, $v_read_size);
     2409      $v_size -= $v_read_size;
     2410    }
     2411
     2412    // ----- Create the Central Dir files header
     2413    for ($i=0, $v_count=0; $i<sizeof($v_header_list); $i++)
     2414    {
     2415      // ----- Create the file header
     2416      if ($v_header_list[$i]['status'] == 'ok') {
     2417        if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
     2418          fclose($v_zip_temp_fd);
     2419          $this->privCloseFd();
     2420          @unlink($v_zip_temp_name);
     2421          $this->privSwapBackMagicQuotes();
     2422
     2423          // ----- Return
     2424          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2425          return $v_result;
     2426        }
     2427        $v_count++;
     2428      }
     2429
     2430      // ----- Transform the header to a 'usable' info
     2431      $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
     2432    }
     2433
     2434    // ----- Zip file comment
     2435    $v_comment = $v_central_dir['comment'];
     2436    if (isset($p_options[PCLZIP_OPT_COMMENT])) {
     2437      $v_comment = $p_options[PCLZIP_OPT_COMMENT];
     2438    }
     2439    if (isset($p_options[PCLZIP_OPT_ADD_COMMENT])) {
     2440      $v_comment = $v_comment.$p_options[PCLZIP_OPT_ADD_COMMENT];
     2441    }
     2442    if (isset($p_options[PCLZIP_OPT_PREPEND_COMMENT])) {
     2443      $v_comment = $p_options[PCLZIP_OPT_PREPEND_COMMENT].$v_comment;
     2444    }
     2445
     2446    // ----- Calculate the size of the central header
     2447    $v_size = @ftell($this->zip_fd)-$v_offset;
     2448
     2449    // ----- Create the central dir footer
     2450    if (($v_result = $this->privWriteCentralHeader($v_count+$v_central_dir['entries'], $v_size, $v_offset, $v_comment)) != 1)
     2451    {
     2452      // ----- Reset the file list
     2453      unset($v_header_list);
     2454      $this->privSwapBackMagicQuotes();
     2455
     2456      // ----- Return
     2457      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2458      return $v_result;
     2459    }
     2460
     2461    // ----- Swap back the file descriptor
     2462    $v_swap = $this->zip_fd;
     2463    $this->zip_fd = $v_zip_temp_fd;
     2464    $v_zip_temp_fd = $v_swap;
     2465
     2466    // ----- Close
     2467    $this->privCloseFd();
     2468
     2469    // ----- Close the temporary file
     2470    @fclose($v_zip_temp_fd);
     2471
     2472    // ----- Magic quotes trick
     2473    $this->privSwapBackMagicQuotes();
     2474
     2475    // ----- Delete the zip file
     2476    // TBC : I should test the result ...
     2477    @unlink($this->zipname);
     2478
     2479    // ----- Rename the temporary file
     2480    // TBC : I should test the result ...
     2481    //@rename($v_zip_temp_name, $this->zipname);
     2482    PclZipUtilRename($v_zip_temp_name, $this->zipname);
     2483
     2484    // ----- Return
     2485    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2486    return $v_result;
    23012487  }
    23022488  // --------------------------------------------------------------------------------
     
    23092495  function privOpenFd($p_mode)
    23102496  {
    2311     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privOpenFd", 'mode='.$p_mode);
    2312     $v_result=1;
    2313 
    2314     // ----- Look if already open
    2315     if ($this->zip_fd != 0)
    2316     {
    2317       // ----- Error log
    2318       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \''.$this->zipname.'\' already open');
    2319 
    2320       // ----- Return
    2321       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    2322       return PclZip::errorCode();
    2323     }
    2324 
    2325     // ----- Open the zip file
    2326     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Open file in '.$p_mode.' mode');
    2327     if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
    2328     {
    2329       // ----- Error log
    2330       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in '.$p_mode.' mode');
    2331 
    2332       // ----- Return
    2333       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    2334       return PclZip::errorCode();
    2335     }
    2336 
    2337     // ----- Return
    2338     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2339     return $v_result;
     2497    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privOpenFd", 'mode='.$p_mode);
     2498    $v_result=1;
     2499
     2500    // ----- Look if already open
     2501    if ($this->zip_fd != 0)
     2502    {
     2503      // ----- Error log
     2504      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \''.$this->zipname.'\' already open');
     2505
     2506      // ----- Return
     2507      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2508      return PclZip::errorCode();
     2509    }
     2510
     2511    // ----- Open the zip file
     2512    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Open file in '.$p_mode.' mode');
     2513    if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
     2514    {
     2515      // ----- Error log
     2516      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in '.$p_mode.' mode');
     2517
     2518      // ----- Return
     2519      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2520      return PclZip::errorCode();
     2521    }
     2522
     2523    // ----- Return
     2524    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2525    return $v_result;
    23402526  }
    23412527  // --------------------------------------------------------------------------------
     
    23482534  function privCloseFd()
    23492535  {
    2350     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCloseFd", "");
    2351     $v_result=1;
    2352 
    2353     if ($this->zip_fd != 0)
    2354       @fclose($this->zip_fd);
    2355     $this->zip_fd = 0;
    2356 
    2357     // ----- Return
    2358     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2359     return $v_result;
     2536    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCloseFd", "");
     2537    $v_result=1;
     2538
     2539    if ($this->zip_fd != 0)
     2540      @fclose($this->zip_fd);
     2541    $this->zip_fd = 0;
     2542
     2543    // ----- Return
     2544    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2545    return $v_result;
    23602546  }
    23612547  // --------------------------------------------------------------------------------
     
    23772563  function privAddList($p_filedescr_list, &$p_result_list, &$p_options)
    23782564  {
    2379     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddList", "list");
    2380     $v_result=1;
    2381 
    2382     // ----- Add the files
    2383     $v_header_list = array();
    2384     if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
    2385     {
    2386       // ----- Return
    2387       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2388       return $v_result;
    2389     }
    2390 
    2391     // ----- Store the offset of the central dir
    2392     $v_offset = @ftell($this->zip_fd);
    2393 
    2394     // ----- Create the Central Dir files header
    2395     for ($i=0,$v_count=0; $i<sizeof($v_header_list); $i++)
    2396     {
    2397       // ----- Create the file header
    2398       if ($v_header_list[$i]['status'] == 'ok') {
    2399         if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
    2400           // ----- Return
    2401           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2402           return $v_result;
    2403         }
    2404         $v_count++;
    2405       }
    2406 
    2407       // ----- Transform the header to a 'usable' info
    2408       $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
    2409     }
    2410 
    2411     // ----- Zip file comment
    2412     $v_comment = '';
    2413     if (isset($p_options[PCLZIP_OPT_COMMENT])) {
    2414       $v_comment = $p_options[PCLZIP_OPT_COMMENT];
    2415     }
    2416 
    2417     // ----- Calculate the size of the central header
    2418     $v_size = @ftell($this->zip_fd)-$v_offset;
    2419 
    2420     // ----- Create the central dir footer
    2421     if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1)
    2422     {
    2423       // ----- Reset the file list
    2424       unset($v_header_list);
    2425 
    2426       // ----- Return
    2427       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2428       return $v_result;
    2429     }
    2430 
    2431     // ----- Return
    2432     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2433     return $v_result;
     2565    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddList", "list");
     2566    $v_result=1;
     2567
     2568    // ----- Add the files
     2569    $v_header_list = array();
     2570    if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
     2571    {
     2572      // ----- Return
     2573      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2574      return $v_result;
     2575    }
     2576
     2577    // ----- Store the offset of the central dir
     2578    $v_offset = @ftell($this->zip_fd);
     2579
     2580    // ----- Create the Central Dir files header
     2581    for ($i=0,$v_count=0; $i<sizeof($v_header_list); $i++)
     2582    {
     2583      // ----- Create the file header
     2584      if ($v_header_list[$i]['status'] == 'ok') {
     2585        if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
     2586          // ----- Return
     2587          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2588          return $v_result;
     2589        }
     2590        $v_count++;
     2591      }
     2592
     2593      // ----- Transform the header to a 'usable' info
     2594      $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
     2595    }
     2596
     2597    // ----- Zip file comment
     2598    $v_comment = '';
     2599    if (isset($p_options[PCLZIP_OPT_COMMENT])) {
     2600      $v_comment = $p_options[PCLZIP_OPT_COMMENT];
     2601    }
     2602
     2603    // ----- Calculate the size of the central header
     2604    $v_size = @ftell($this->zip_fd)-$v_offset;
     2605
     2606    // ----- Create the central dir footer
     2607    if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1)
     2608    {
     2609      // ----- Reset the file list
     2610      unset($v_header_list);
     2611
     2612      // ----- Return
     2613      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2614      return $v_result;
     2615    }
     2616
     2617    // ----- Return
     2618    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2619    return $v_result;
    24342620  }
    24352621  // --------------------------------------------------------------------------------
     
    24392625  // Description :
    24402626  // Parameters :
    2441   //   $p_filedescr_list : An array containing the file description
    2442   //                      or directory names to add in the zip
     2627  //   $p_filedescr_list : An array containing the file description 
     2628  //                      or directory names to add in the zip
    24432629  //   $p_result_list : list of added files with their properties (specially the status field)
    24442630  // Return Values :
     
    24462632  function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options)
    24472633  {
    2448     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddFileList", "filedescr_list");
    2449     $v_result=1;
    2450     $v_header = array();
    2451 
    2452     // ----- Recuperate the current number of elt in list
    2453     $v_nb = sizeof($p_result_list);
    2454     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Before add, list have ".$v_nb." elements");
    2455 
    2456     // ----- Loop on the files
    2457     for ($j=0; ($j<sizeof($p_filedescr_list)) && ($v_result==1); $j++) {
    2458       // ----- Format the filename
    2459       $p_filedescr_list[$j]['filename']
    2460       = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
    2461 
    2462       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Looking for file '".$p_filedescr_list[$j]['filename']."'");
    2463 
    2464       // ----- Skip empty file names
    2465       // TBC : Can this be possible ? not checked in DescrParseAtt ?
    2466       if ($p_filedescr_list[$j]['filename'] == "") {
    2467         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Skip empty filename");
    2468         continue;
    2469       }
    2470 
    2471       // ----- Check the filename
    2472       if (!file_exists($p_filedescr_list[$j]['filename'])) {
    2473         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$p_filedescr_list[$j]['filename']."' does not exists");
    2474         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exists");
    2475         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    2476         return PclZip::errorCode();
    2477       }
    2478 
    2479       // ----- Look if it is a file or a dir with no all path remove option
    2480       if (   (is_file($p_filedescr_list[$j]['filename']))
    2481           || (   is_dir($p_filedescr_list[$j]['filename'])
    2482               && (   !isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
    2483                   || !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))) {
    2484 
    2485         // ----- Add the file
    2486         $v_result = $this->privAddFile($p_filedescr_list[$j], $v_header,
    2487                                        $p_options);
    2488         if ($v_result != 1) {
    2489           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2490           return $v_result;
    2491         }
    2492 
    2493         // ----- Store the file infos
    2494         $p_result_list[$v_nb++] = $v_header;
    2495       }
    2496     }
    2497     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "After add, list have ".$v_nb." elements");
    2498 
    2499     // ----- Return
    2500     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2501     return $v_result;
     2634    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddFileList", "filedescr_list");
     2635    $v_result=1;
     2636    $v_header = array();
     2637
     2638    // ----- Recuperate the current number of elt in list
     2639    $v_nb = sizeof($p_result_list);
     2640    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Before add, list have ".$v_nb." elements");
     2641
     2642    // ----- Loop on the files
     2643    for ($j=0; ($j<sizeof($p_filedescr_list)) && ($v_result==1); $j++) {
     2644      // ----- Format the filename
     2645      $p_filedescr_list[$j]['filename']
     2646      = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
     2647     
     2648      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Looking for file '".$p_filedescr_list[$j]['filename']."'");
     2649
     2650      // ----- Skip empty file names
     2651      // TBC : Can this be possible ? not checked in DescrParseAtt ?
     2652      if ($p_filedescr_list[$j]['filename'] == "") {
     2653        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Skip empty filename");
     2654        continue;
     2655      }
     2656
     2657      // ----- Check the filename
     2658      if (   ($p_filedescr_list[$j]['type'] != 'virtual_file')
     2659          && (!file_exists($p_filedescr_list[$j]['filename']))) {
     2660        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$p_filedescr_list[$j]['filename']."' does not exist");
     2661        PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exist");
     2662        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2663        return PclZip::errorCode();
     2664      }
     2665
     2666      // ----- Look if it is a file or a dir with no all path remove option
     2667      // or a dir with all its path removed
     2668//    if (   (is_file($p_filedescr_list[$j]['filename']))
     2669//        || (   is_dir($p_filedescr_list[$j]['filename'])
     2670      if (   ($p_filedescr_list[$j]['type'] == 'file')
     2671          || ($p_filedescr_list[$j]['type'] == 'virtual_file')
     2672          || (   ($p_filedescr_list[$j]['type'] == 'folder')
     2673              && (   !isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
     2674                  || !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))
     2675          ) {
     2676
     2677        // ----- Add the file
     2678        $v_result = $this->privAddFile($p_filedescr_list[$j], $v_header,
     2679                                       $p_options);
     2680        if ($v_result != 1) {
     2681          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2682          return $v_result;
     2683        }
     2684
     2685        // ----- Store the file infos
     2686        $p_result_list[$v_nb++] = $v_header;
     2687      }
     2688    }
     2689    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "After add, list have ".$v_nb." elements");
     2690
     2691    // ----- Return
     2692    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2693    return $v_result;
    25022694  }
    25032695  // --------------------------------------------------------------------------------
     
    25112703  function privAddFile($p_filedescr, &$p_header, &$p_options)
    25122704  {
    2513     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddFile", "filename='".$p_filedescr['filename']."'");
    2514     $v_result=1;
    2515 
    2516     // ----- Working variable
    2517     $p_filename = $p_filedescr['filename'];
    2518 
    2519     // TBC : Already done in the fileAtt check ... ?
    2520     if ($p_filename == "") {
    2521       // ----- Error log
    2522       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file list parameter (invalid or empty list)");
    2523 
    2524       // ----- Return
    2525       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    2526       return PclZip::errorCode();
    2527     }
    2528 
    2529     // ----- Look for a stored different filename
    2530     if (isset($p_filedescr['stored_filename'])) {
    2531       $v_stored_filename = $p_filedescr['stored_filename'];
    2532       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'Stored filename is NOT the same "'.$v_stored_filename.'"');
    2533     }
    2534     else {
    2535       $v_stored_filename = $p_filedescr['stored_filename'];
    2536       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'Stored filename is the same');
    2537     }
    2538 
    2539     // ----- Set the file properties
    2540     clearstatcache();
    2541     $p_header['version'] = 20;
    2542     $p_header['version_extracted'] = 10;
    2543     $p_header['flag'] = 0;
    2544     $p_header['compression'] = 0;
    2545     $p_header['mtime'] = filemtime($p_filename);
    2546     $p_header['crc'] = 0;
    2547     $p_header['compressed_size'] = 0;
    2548     $p_header['size'] = filesize($p_filename);
    2549     $p_header['filename_len'] = strlen($p_filename);
    2550     $p_header['extra_len'] = 0;
    2551     $p_header['comment_len'] = 0;
    2552     $p_header['disk'] = 0;
    2553     $p_header['internal'] = 0;
    2554 //    $p_header['external'] = (is_file($p_filename)?0xFE49FFE0:0x41FF0010);
    2555     $p_header['external'] = (is_file($p_filename)?0x00000000:0x00000010);
    2556     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Header external extension '".sprintf("0x%X",$p_header['external'])."'");
    2557     $p_header['offset'] = 0;
    2558     $p_header['filename'] = $p_filename;
    2559     $p_header['stored_filename'] = $v_stored_filename;
    2560     $p_header['extra'] = '';
    2561     $p_header['comment'] = '';
    2562     $p_header['status'] = 'ok';
    2563     $p_header['index'] = -1;
    2564 
    2565     // ----- Look for pre-add callback
    2566     if (isset($p_options[PCLZIP_CB_PRE_ADD])) {
    2567       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A pre-callback '".$p_options[PCLZIP_CB_PRE_ADD]."()') is defined for the extraction");
    2568 
    2569       // ----- Generate a local information
    2570       $v_local_header = array();
    2571       $this->privConvertHeader2FileInfo($p_header, $v_local_header);
    2572 
    2573       // ----- Call the callback
    2574       // Here I do not use call_user_func() because I need to send a reference to the
    2575       // header.
    2576       eval('$v_result = '.$p_options[PCLZIP_CB_PRE_ADD].'(PCLZIP_CB_PRE_ADD, $v_local_header);');
    2577       if ($v_result == 0) {
    2578         // ----- Change the file status
    2579         $p_header['status'] = "skipped";
    2580         $v_result = 1;
    2581       }
    2582 
    2583       // ----- Update the informations
    2584       // Only some fields can be modified
    2585       if ($p_header['stored_filename'] != $v_local_header['stored_filename']) {
    2586         $p_header['stored_filename'] = PclZipUtilPathReduction($v_local_header['stored_filename']);
    2587         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "New stored filename is '".$p_header['stored_filename']."'");
    2588       }
    2589     }
    2590 
    2591     // ----- Look for empty stored filename
    2592     if ($p_header['stored_filename'] == "") {
    2593       $p_header['status'] = "filtered";
    2594     }
    2595 
    2596     // ----- Check the path length
    2597     if (strlen($p_header['stored_filename']) > 0xFF) {
    2598       $p_header['status'] = 'filename_too_long';
    2599     }
    2600 
    2601     // ----- Look if no error, or file not skipped
    2602     if ($p_header['status'] == 'ok') {
    2603 
    2604       // ----- Look for a file
    2605       if (is_file($p_filename))
    2606       {
    2607         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a file");
    2608         // ----- Open the source file
    2609         if (($v_file = @fopen($p_filename, "rb")) == 0) {
    2610           PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
    2611           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    2612           return PclZip::errorCode();
    2613         }
    2614 
    2615         if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
    2616           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will not be compressed");
    2617           // ----- Read the file content
    2618           $v_content_compressed = @fread($v_file, $p_header['size']);
    2619 
    2620           // ----- Calculate the CRC
    2621           $p_header['crc'] = @crc32($v_content_compressed);
    2622 
    2623           // ----- Set header parameters
    2624           $p_header['compressed_size'] = $p_header['size'];
    2625           $p_header['compression'] = 0;
    2626         }
    2627         else {
    2628           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will be compressed");
    2629           // ----- Read the file content
    2630           $v_content = @fread($v_file, $p_header['size']);
    2631 
    2632           // ----- Calculate the CRC
    2633           $p_header['crc'] = @crc32($v_content);
    2634 
    2635           // ----- Compress the file
    2636           $v_content_compressed = @gzdeflate($v_content);
    2637 
    2638           // ----- Set header parameters
    2639           $p_header['compressed_size'] = strlen($v_content_compressed);
    2640           $p_header['compression'] = 8;
    2641         }
    2642 
    2643         // ----- Look for encryption
    2644         /*
    2645         if ((isset($p_options[PCLZIP_OPT_CRYPT]))
    2646             && ($p_options[PCLZIP_OPT_CRYPT] != "")) {
    2647           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File need to be crypted ....");
    2648 
    2649           // Should be a random header
    2650           $v_header = 'xxxxxxxxxxxx';
    2651           $v_content_compressed = PclZipUtilZipEncrypt($v_content_compressed,
    2652                                                    $p_header['compressed_size'],
    2653                                                    $v_header,
     2705    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddFile", "filename='".$p_filedescr['filename']."'");
     2706    $v_result=1;
     2707   
     2708    // ----- Working variable
     2709    $p_filename = $p_filedescr['filename'];
     2710
     2711    // TBC : Already done in the fileAtt check ... ?
     2712    if ($p_filename == "") {
     2713      // ----- Error log
     2714      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file list parameter (invalid or empty list)");
     2715
     2716      // ----- Return
     2717      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2718      return PclZip::errorCode();
     2719    }
     2720 
     2721    // ----- Look for a stored different filename
     2722    /* TBC : Removed
     2723    if (isset($p_filedescr['stored_filename'])) {
     2724      $v_stored_filename = $p_filedescr['stored_filename'];
     2725      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'Stored filename is NOT the same "'.$v_stored_filename.'"');
     2726    }
     2727    else {
     2728      $v_stored_filename = $p_filedescr['stored_filename'];
     2729      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'Stored filename is the same');
     2730    }
     2731    */
     2732
     2733    // ----- Set the file properties
     2734    clearstatcache();
     2735    $p_header['version'] = 20;
     2736    $p_header['version_extracted'] = 10;
     2737    $p_header['flag'] = 0;
     2738    $p_header['compression'] = 0;
     2739    $p_header['crc'] = 0;
     2740    $p_header['compressed_size'] = 0;
     2741    $p_header['filename_len'] = strlen($p_filename);
     2742    $p_header['extra_len'] = 0;
     2743    $p_header['disk'] = 0;
     2744    $p_header['internal'] = 0;
     2745    $p_header['offset'] = 0;
     2746    $p_header['filename'] = $p_filename;
     2747// TBC : Removed    $p_header['stored_filename'] = $v_stored_filename;
     2748    $p_header['stored_filename'] = $p_filedescr['stored_filename'];
     2749    $p_header['extra'] = '';
     2750    $p_header['status'] = 'ok';
     2751    $p_header['index'] = -1;
     2752
     2753    // ----- Look for regular file
     2754    if ($p_filedescr['type']=='file') {
     2755      $p_header['external'] = 0x00000000;
     2756      $p_header['size'] = filesize($p_filename);
     2757    }
     2758   
     2759    // ----- Look for regular folder
     2760    else if ($p_filedescr['type']=='folder') {
     2761      $p_header['external'] = 0x00000010;
     2762      $p_header['mtime'] = filemtime($p_filename);
     2763      $p_header['size'] = filesize($p_filename);
     2764    }
     2765   
     2766    // ----- Look for virtual file
     2767    else if ($p_filedescr['type'] == 'virtual_file') {
     2768      $p_header['external'] = 0x00000000;
     2769      $p_header['size'] = strlen($p_filedescr['content']);
     2770    }
     2771   
     2772    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Header external extension '".sprintf("0x%X",$p_header['external'])."'");
     2773
     2774    // ----- Look for filetime
     2775    if (isset($p_filedescr['mtime'])) {
     2776      $p_header['mtime'] = $p_filedescr['mtime'];
     2777    }
     2778    else if ($p_filedescr['type'] == 'virtual_file') {
     2779      $p_header['mtime'] = time();
     2780    }
     2781    else {
     2782      $p_header['mtime'] = filemtime($p_filename);
     2783    }
     2784
     2785    // ------ Look for file comment
     2786    if (isset($p_filedescr['comment'])) {
     2787      $p_header['comment_len'] = strlen($p_filedescr['comment']);
     2788      $p_header['comment'] = $p_filedescr['comment'];
     2789    }
     2790    else {
     2791      $p_header['comment_len'] = 0;
     2792      $p_header['comment'] = '';
     2793    }
     2794
     2795    // ----- Look for pre-add callback
     2796    if (isset($p_options[PCLZIP_CB_PRE_ADD])) {
     2797      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A pre-callback '".$p_options[PCLZIP_CB_PRE_ADD]."()') is defined for the extraction");
     2798
     2799      // ----- Generate a local information
     2800      $v_local_header = array();
     2801      $this->privConvertHeader2FileInfo($p_header, $v_local_header);
     2802
     2803      // ----- Call the callback
     2804      // Here I do not use call_user_func() because I need to send a reference to the
     2805      // header.
     2806      eval('$v_result = '.$p_options[PCLZIP_CB_PRE_ADD].'(PCLZIP_CB_PRE_ADD, $v_local_header);');
     2807      if ($v_result == 0) {
     2808        // ----- Change the file status
     2809        $p_header['status'] = "skipped";
     2810        $v_result = 1;
     2811      }
     2812
     2813      // ----- Update the informations
     2814      // Only some fields can be modified
     2815      if ($p_header['stored_filename'] != $v_local_header['stored_filename']) {
     2816        $p_header['stored_filename'] = PclZipUtilPathReduction($v_local_header['stored_filename']);
     2817        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "New stored filename is '".$p_header['stored_filename']."'");
     2818      }
     2819    }
     2820
     2821    // ----- Look for empty stored filename
     2822    if ($p_header['stored_filename'] == "") {
     2823      $p_header['status'] = "filtered";
     2824    }
     2825   
     2826    // ----- Check the path length
     2827    if (strlen($p_header['stored_filename']) > 0xFF) {
     2828      $p_header['status'] = 'filename_too_long';
     2829    }
     2830
     2831    // ----- Look if no error, or file not skipped
     2832    if ($p_header['status'] == 'ok') {
     2833
     2834      // ----- Look for a file
     2835      if ($p_filedescr['type'] == 'file') {
     2836        // ----- Look for using temporary file to zip
     2837        if ( (!isset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_OFF]))
     2838            && (isset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_ON])
     2839                || (isset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])
     2840                    && ($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
     2841          $v_result = $this->privAddFileUsingTempFile($p_filedescr, $p_header, $p_options);
     2842          if ($v_result >= PCLZIP_ERR_NO_ERROR) {
     2843            return $v_result;
     2844          }
     2845        }
     2846       
     2847        // ----- Use "in memory" zip algo
     2848        else {
     2849         
     2850        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a file");
     2851
     2852        // ----- Open the source file
     2853        if (($v_file = @fopen($p_filename, "rb")) == 0) {
     2854          PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
     2855          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2856          return PclZip::errorCode();
     2857        }
     2858
     2859        // ----- Read the file content
     2860        $v_content = @fread($v_file, $p_header['size']);
     2861
     2862        // ----- Close the file
     2863        @fclose($v_file);
     2864
     2865        // ----- Calculate the CRC
     2866        $p_header['crc'] = @crc32($v_content);
     2867       
     2868        // ----- Look for no compression
     2869        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
     2870          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will not be compressed");
     2871          // ----- Set header parameters
     2872          $p_header['compressed_size'] = $p_header['size'];
     2873          $p_header['compression'] = 0;
     2874        }
     2875       
     2876        // ----- Look for normal compression
     2877        else {
     2878          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will be compressed");
     2879          // ----- Compress the content
     2880          $v_content = @gzdeflate($v_content);
     2881
     2882          // ----- Set header parameters
     2883          $p_header['compressed_size'] = strlen($v_content);
     2884          $p_header['compression'] = 8;
     2885        }
     2886       
     2887        // ----- Look for encryption
     2888        /*
     2889        if ((isset($p_options[PCLZIP_OPT_CRYPT]))
     2890            && ($p_options[PCLZIP_OPT_CRYPT] != "")) {
     2891          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File need to be crypted ....");
     2892         
     2893          // Should be a random header
     2894          $v_header = 'xxxxxxxxxxxx';
     2895          $v_content_compressed = PclZipUtilZipEncrypt($v_content_compressed,
     2896                                                   $p_header['compressed_size'],
     2897                                                   $v_header,
    26542898                                                   $p_header['crc'],
    26552899                                                   "test");
    2656 
    2657           $p_header['compressed_size'] += 12;
    2658           $p_header['flag'] = 1;
    2659 
    2660           // ----- Add the header to the data
    2661           $v_content_compressed = $v_header.$v_content_compressed;
    2662           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size after header : ".strlen($v_content_compressed)."");
    2663         }
    2664         */
    2665 
    2666         // ----- Call the header generation
    2667         if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
    2668           @fclose($v_file);
    2669           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2670           return $v_result;
    2671         }
    2672 
    2673         // ----- Write the compressed (or not) content
    2674         @fwrite($this->zip_fd,
    2675                     $v_content_compressed, $p_header['compressed_size']);
    2676 
    2677         // ----- Close the file
    2678         @fclose($v_file);
    2679       }
    2680 
    2681       // ----- Look for a directory
    2682       else {
    2683         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a folder");
    2684         // ----- Look for directory last '/'
    2685         if (@substr($p_header['stored_filename'], -1) != '/') {
    2686           $p_header['stored_filename'] .= '/';
    2687         }
    2688 
    2689         // ----- Set the file properties
    2690         $p_header['size'] = 0;
    2691         //$p_header['external'] = 0x41FF0010;   // Value for a folder : to be checked
    2692         $p_header['external'] = 0x00000010;   // Value for a folder : to be checked
    2693 
    2694         // ----- Call the header generation
    2695         if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
    2696         {
    2697           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2698           return $v_result;
    2699         }
    2700       }
    2701     }
    2702 
    2703     // ----- Look for post-add callback
    2704     if (isset($p_options[PCLZIP_CB_POST_ADD])) {
    2705       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A post-callback '".$p_options[PCLZIP_CB_POST_ADD]."()') is defined for the extraction");
    2706 
    2707       // ----- Generate a local information
    2708       $v_local_header = array();
    2709       $this->privConvertHeader2FileInfo($p_header, $v_local_header);
    2710 
    2711       // ----- Call the callback
    2712       // Here I do not use call_user_func() because I need to send a reference to the
    2713       // header.
    2714       eval('$v_result = '.$p_options[PCLZIP_CB_POST_ADD].'(PCLZIP_CB_POST_ADD, $v_local_header);');
    2715       if ($v_result == 0) {
    2716         // ----- Ignored
    2717         $v_result = 1;
    2718       }
    2719 
    2720       // ----- Update the informations
    2721       // Nothing can be modified
    2722     }
    2723 
    2724     // ----- Return
    2725     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2726     return $v_result;
     2900                                                   
     2901          $p_header['compressed_size'] += 12;
     2902          $p_header['flag'] = 1;
     2903         
     2904          // ----- Add the header to the data
     2905          $v_content_compressed = $v_header.$v_content_compressed;
     2906          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size after header : ".strlen($v_content_compressed)."");
     2907        }
     2908        */
     2909
     2910        // ----- Call the header generation
     2911        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     2912          @fclose($v_file);
     2913          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2914          return $v_result;
     2915        }
     2916
     2917        // ----- Write the compressed (or not) content
     2918        @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
     2919
     2920        }
     2921
     2922      }
     2923
     2924      // ----- Look for a virtual file (a file from string)
     2925      else if ($p_filedescr['type'] == 'virtual_file') {
     2926         
     2927        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Add by string");
     2928        $v_content = $p_filedescr['content'];
     2929
     2930        // ----- Calculate the CRC
     2931        $p_header['crc'] = @crc32($v_content);
     2932       
     2933        // ----- Look for no compression
     2934        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
     2935          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will not be compressed");
     2936          // ----- Set header parameters
     2937          $p_header['compressed_size'] = $p_header['size'];
     2938          $p_header['compression'] = 0;
     2939        }
     2940       
     2941        // ----- Look for normal compression
     2942        else {
     2943          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will be compressed");
     2944          // ----- Compress the content
     2945          $v_content = @gzdeflate($v_content);
     2946
     2947          // ----- Set header parameters
     2948          $p_header['compressed_size'] = strlen($v_content);
     2949          $p_header['compression'] = 8;
     2950        }
     2951       
     2952        // ----- Look for encryption
     2953        /*
     2954        if ((isset($p_options[PCLZIP_OPT_CRYPT]))
     2955            && ($p_options[PCLZIP_OPT_CRYPT] != "")) {
     2956          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File need to be crypted ....");
     2957         
     2958          // Should be a random header
     2959          $v_header = 'xxxxxxxxxxxx';
     2960          $v_content_compressed = PclZipUtilZipEncrypt($v_content_compressed,
     2961                                                   $p_header['compressed_size'],
     2962                                                   $v_header,
     2963                                                   $p_header['crc'],
     2964                                                   "test");
     2965                                                   
     2966          $p_header['compressed_size'] += 12;
     2967          $p_header['flag'] = 1;
     2968         
     2969          // ----- Add the header to the data
     2970          $v_content_compressed = $v_header.$v_content_compressed;
     2971          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size after header : ".strlen($v_content_compressed)."");
     2972        }
     2973        */
     2974
     2975        // ----- Call the header generation
     2976        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     2977          @fclose($v_file);
     2978          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2979          return $v_result;
     2980        }
     2981
     2982        // ----- Write the compressed (or not) content
     2983        @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
     2984      }
     2985
     2986      // ----- Look for a directory
     2987      else if ($p_filedescr['type'] == 'folder') {
     2988        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a folder");
     2989        // ----- Look for directory last '/'
     2990        if (@substr($p_header['stored_filename'], -1) != '/') {
     2991          $p_header['stored_filename'] .= '/';
     2992        }
     2993
     2994        // ----- Set the file properties
     2995        $p_header['size'] = 0;
     2996        //$p_header['external'] = 0x41FF0010;   // Value for a folder : to be checked
     2997        $p_header['external'] = 0x00000010;   // Value for a folder : to be checked
     2998
     2999        // ----- Call the header generation
     3000        if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
     3001        {
     3002          //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     3003          return $v_result;
     3004        }
     3005      }
     3006    }
     3007
     3008    // ----- Look for post-add callback
     3009    if (isset($p_options[PCLZIP_CB_POST_ADD])) {
     3010      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A post-callback '".$p_options[PCLZIP_CB_POST_ADD]."()') is defined for the extraction");
     3011
     3012      // ----- Generate a local information
     3013      $v_local_header = array();
     3014      $this->privConvertHeader2FileInfo($p_header, $v_local_header);
     3015
     3016      // ----- Call the callback
     3017      // Here I do not use call_user_func() because I need to send a reference to the
     3018      // header.
     3019      eval('$v_result = '.$p_options[PCLZIP_CB_POST_ADD].'(PCLZIP_CB_POST_ADD, $v_local_header);');
     3020      if ($v_result == 0) {
     3021        // ----- Ignored
     3022        $v_result = 1;
     3023      }
     3024
     3025      // ----- Update the informations
     3026      // Nothing can be modified
     3027    }
     3028
     3029    // ----- Return
     3030    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     3031    return $v_result;
     3032  }
     3033  // --------------------------------------------------------------------------------
     3034
     3035  // --------------------------------------------------------------------------------
     3036  // Function : privAddFileUsingTempFile()
     3037  // Description :
     3038  // Parameters :
     3039  // Return Values :
     3040  // --------------------------------------------------------------------------------
     3041  function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options)
     3042  {
     3043    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddFileUsingTempFile", "filename='".$p_filedescr['filename']."'");
     3044    $v_result=PCLZIP_ERR_NO_ERROR;
     3045   
     3046    // ----- Working variable
     3047    $p_filename = $p_filedescr['filename'];
     3048
     3049    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a file");
     3050
     3051    // ----- Open the source file
     3052    if (($v_file = @fopen($p_filename, "rb")) == 0) {
     3053      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
     3054      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     3055      return PclZip::errorCode();
     3056    }
     3057
     3058    // ----- Creates a compressed temporary file
     3059    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
     3060    if (($v_file_compressed = @gzopen($v_gzip_temp_name, "wb")) == 0) {
     3061      fclose($v_file);
     3062      PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
     3063      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     3064      return PclZip::errorCode();
     3065    }
     3066
     3067    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     3068    $v_size = filesize($p_filename);
     3069    while ($v_size != 0) {
     3070      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     3071      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read $v_read_size bytes");
     3072      $v_buffer = fread($v_file, $v_read_size);
     3073      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     3074      @gzputs($v_file_compressed, $v_buffer, $v_read_size);
     3075      $v_size -= $v_read_size;
     3076    }
     3077
     3078    // ----- Close the file
     3079    @fclose($v_file);
     3080    @gzclose($v_file_compressed);
     3081
     3082    // ----- Check the minimum file size
     3083    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "gzip file size ".filesize($v_gzip_temp_name));
     3084    if (filesize($v_gzip_temp_name) < 18) {
     3085      PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'gzip temporary file \''.$v_gzip_temp_name.'\' has invalid filesize - should be minimum 18 bytes');
     3086      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     3087      return PclZip::errorCode();
     3088    }
     3089
     3090    // ----- Extract the compressed attributes
     3091    if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0) {
     3092      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     3093      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     3094      return PclZip::errorCode();
     3095    }
     3096
     3097    // ----- Read the gzip file header
     3098    $v_binary_data = @fread($v_file_compressed, 10);
     3099    $v_data_header = unpack('a1id1/a1id2/a1cm/a1flag/Vmtime/a1xfl/a1os', $v_binary_data);
     3100
     3101    // ----- Check some parameters
     3102    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, '$v_data_header[id1]='.bin2hex($v_data_header['id1']));
     3103    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, '$v_data_header[id2]='.bin2hex($v_data_header['id2']));
     3104    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, '$v_data_header[cm]='.bin2hex($v_data_header['cm']));
     3105    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, '$v_data_header[flag]='.bin2hex($v_data_header['flag']));
     3106    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, '$v_data_header[mtime]='.$v_data_header['mtime']);
     3107    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, '$v_data_header[xfl]='.bin2hex($v_data_header['xfl']));
     3108    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, '$v_data_header[os]='.bin2hex($v_data_header['os']));
     3109    $v_data_header['os'] = bin2hex($v_data_header['os']);
     3110
     3111    // ----- Read the gzip file footer
     3112    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "File position after header ".ftell($v_file_compressed));
     3113    @fseek($v_file_compressed, filesize($v_gzip_temp_name)-8);
     3114    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "File position at beginning of footer ".ftell($v_file_compressed));
     3115    $v_binary_data = @fread($v_file_compressed, 8);
     3116    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "File position after footer ".ftell($v_file_compressed));
     3117    $v_data_footer = unpack('Vcrc/Vcompressed_size', $v_binary_data);
     3118
     3119    // ----- Set the attributes
     3120    $p_header['compression'] = ord($v_data_header['cm']);
     3121    //$p_header['mtime'] = $v_data_header['mtime'];
     3122    $p_header['crc'] = $v_data_footer['crc'];
     3123    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Compressed size ".(filesize($v_gzip_temp_name)-18));
     3124    $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;
     3125
     3126    // ----- Close the file
     3127    @fclose($v_file_compressed);
     3128
     3129    // ----- Call the header generation
     3130    if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     3131      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     3132      return $v_result;
     3133    }
     3134
     3135    // ----- Add the compressed data
     3136    if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0)
     3137    {
     3138      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     3139      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     3140      return PclZip::errorCode();
     3141    }
     3142
     3143    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     3144    fseek($v_file_compressed, 10);
     3145    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "File position before reading compressed data ".ftell($v_file_compressed));
     3146    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, ' '.$p_header['compressed_size'].' bytes to read');
     3147    $v_size = $p_header['compressed_size'];
     3148    while ($v_size != 0)
     3149    {
     3150      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     3151      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read $v_read_size bytes");
     3152      $v_buffer = fread($v_file_compressed, $v_read_size);
     3153      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     3154      @fwrite($this->zip_fd, $v_buffer, $v_read_size);
     3155      $v_size -= $v_read_size;
     3156    }
     3157
     3158    // ----- Close the file
     3159    @fclose($v_file_compressed);
     3160
     3161    // ----- Unlink the temporary file
     3162    @unlink($v_gzip_temp_name);
     3163   
     3164    // ----- Return
     3165    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     3166    return $v_result;
    27273167  }
    27283168  // --------------------------------------------------------------------------------
     
    27383178  function privCalculateStoredFilename(&$p_filedescr, &$p_options)
    27393179  {
    2740     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCalculateStoredFilename", "filename='".$p_filedescr['filename']."'");
    2741     $v_result=1;
    2742 
    2743     // ----- Working variables
    2744     $p_filename = $p_filedescr['filename'];
    2745     if (isset($p_options[PCLZIP_OPT_ADD_PATH])) {
    2746       $p_add_dir = $p_options[PCLZIP_OPT_ADD_PATH];
    2747     }
    2748     else {
    2749       $p_add_dir = '';
    2750     }
    2751     if (isset($p_options[PCLZIP_OPT_REMOVE_PATH])) {
    2752       $p_remove_dir = $p_options[PCLZIP_OPT_REMOVE_PATH];
    2753     }
    2754     else {
    2755       $p_remove_dir = '';
    2756     }
    2757     if (isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
    2758       $p_remove_all_dir = $p_options[PCLZIP_OPT_REMOVE_ALL_PATH];
    2759     }
    2760     else {
    2761       $p_remove_all_dir = 0;
    2762     }
    2763 
    2764     // ----- Look for full name change
    2765     if (isset($p_filedescr['new_full_name'])) {
    2766       $v_stored_filename = $p_filedescr['new_full_name'];
    2767       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Changing full name of '".$p_filename."' for '".$v_stored_filename."'");
    2768     }
    2769 
    2770     // ----- Look for path and/or short name change
    2771     else {
    2772 
    2773       // ----- Look for short name change
    2774       if (isset($p_filedescr['new_short_name'])) {
    2775         $v_path_info = pathinfo($p_filename);
    2776         $v_dir = '';
    2777         if ($v_path_info['dirname'] != '') {
    2778           $v_dir = $v_path_info['dirname'].'/';
    2779         }
    2780         $v_stored_filename = $v_dir.$p_filedescr['new_short_name'];
    2781         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Changing short name of '".$p_filename."' for '".$v_stored_filename."'");
    2782       }
    2783       else {
    2784         // ----- Calculate the stored filename
    2785         $v_stored_filename = $p_filename;
    2786       }
    2787 
    2788       // ----- Look for all path to remove
    2789       if ($p_remove_all_dir) {
    2790         $v_stored_filename = basename($p_filename);
    2791         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Remove all path selected change '".$p_filename."' for '".$v_stored_filename."'");
    2792       }
    2793       // ----- Look for partial path remove
    2794       else if ($p_remove_dir != "") {
    2795         if (substr($p_remove_dir, -1) != '/')
    2796           $p_remove_dir .= "/";
    2797 
    2798         if (   (substr($p_filename, 0, 2) == "./")
    2799             || (substr($p_remove_dir, 0, 2) == "./")) {
    2800 
    2801           if (   (substr($p_filename, 0, 2) == "./")
    2802               && (substr($p_remove_dir, 0, 2) != "./")) {
    2803             $p_remove_dir = "./".$p_remove_dir;
    2804           }
    2805           if (   (substr($p_filename, 0, 2) != "./")
    2806               && (substr($p_remove_dir, 0, 2) == "./")) {
    2807             $p_remove_dir = substr($p_remove_dir, 2);
    2808           }
    2809         }
    2810 
    2811         $v_compare = PclZipUtilPathInclusion($p_remove_dir,
    2812                                              $v_stored_filename);
    2813         if ($v_compare > 0) {
    2814           if ($v_compare == 2) {
    2815             $v_stored_filename = "";
    2816             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Path to remove is the current folder");
    2817           }
    2818           else {
    2819             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Remove path '$p_remove_dir' in file '$v_stored_filename'");
    2820             $v_stored_filename = substr($v_stored_filename,
    2821                                         strlen($p_remove_dir));
    2822             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Result is '$v_stored_filename'");
    2823           }
    2824         }
    2825       }
    2826       // ----- Look for path to add
    2827       if ($p_add_dir != "") {
    2828         if (substr($p_add_dir, -1) == "/")
    2829           $v_stored_filename = $p_add_dir.$v_stored_filename;
    2830         else
    2831           $v_stored_filename = $p_add_dir."/".$v_stored_filename;
    2832         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Add path '$p_add_dir' in file '$p_filename' = '$v_stored_filename'");
    2833       }
    2834     }
    2835 
    2836     // ----- Filename (reduce the path of stored name)
    2837     $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
    2838     $p_filedescr['stored_filename'] = $v_stored_filename;
    2839     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Stored filename will be '".$p_filedescr['stored_filename']."', strlen ".strlen($p_filedescr['stored_filename']));
    2840 
    2841     // ----- Return
    2842     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    2843     return $v_result;
     3180    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCalculateStoredFilename", "filename='".$p_filedescr['filename']."'");
     3181    $v_result=1;
     3182   
     3183    // ----- Working variables
     3184    $p_filename = $p_filedescr['filename'];
     3185    if (isset($p_options[PCLZIP_OPT_ADD_PATH])) {
     3186      $p_add_dir = $p_options[PCLZIP_OPT_ADD_PATH];
     3187    }
     3188    else {
     3189      $p_add_dir = '';
     3190    }
     3191    if (isset($p_options[PCLZIP_OPT_REMOVE_PATH])) {
     3192      $p_remove_dir = $p_options[PCLZIP_OPT_REMOVE_PATH];
     3193    }
     3194    else {
     3195      $p_remove_dir = '';
     3196    }
     3197    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Remove path ='".$p_remove_dir."'");
     3198    if (isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
     3199      $p_remove_all_dir = $p_options[PCLZIP_OPT_REMOVE_ALL_PATH];
     3200    }
     3201    else {
     3202      $p_remove_all_dir = 0;
     3203    }
     3204
     3205    // ----- Look for full name change
     3206    if (isset($p_filedescr['new_full_name'])) {
     3207      // ----- Remove drive letter if any
     3208      $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
     3209      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Changing full name of '".$p_filename."' for '".$v_stored_filename."'");
     3210    }
     3211   
     3212    // ----- Look for path and/or short name change
     3213    else {
     3214
     3215      // ----- Look for short name change
     3216      // Its when we cahnge just the filename but not the path
     3217      if (isset($p_filedescr['new_short_name'])) {
     3218        $v_path_info = pathinfo($p_filename);
     3219        $v_dir = '';
     3220        if ($v_path_info['dirname'] != '') {
     3221          $v_dir = $v_path_info['dirname'].'/';
     3222        }
     3223        $v_stored_filename = $v_dir.$p_filedescr['new_short_name'];
     3224        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Changing short name of '".$p_filename."' for '".$v_stored_filename."'");
     3225      }
     3226      else {
     3227        // ----- Calculate the stored filename
     3228        $v_stored_filename = $p_filename;
     3229      }
     3230
     3231      // ----- Look for all path to remove
     3232      if ($p_remove_all_dir) {
     3233        $v_stored_filename = basename($p_filename);
     3234        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Remove all path selected change '".$p_filename."' for '".$v_stored_filename."'");
     3235      }
     3236      // ----- Look for partial path remove
     3237      else if ($p_remove_dir != "") {
     3238        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Partial path to remove");
     3239        if (substr($p_remove_dir, -1) != '/')
     3240          $p_remove_dir .= "/";
     3241
     3242        if (   (substr($p_filename, 0, 2) == "./")
     3243            || (substr($p_remove_dir, 0, 2) == "./")) {
     3244           
     3245          if (   (substr($p_filename, 0, 2) == "./")
     3246              && (substr($p_remove_dir, 0, 2) != "./")) {
     3247            $p_remove_dir = "./".$p_remove_dir;
     3248          }
     3249          if (   (substr($p_filename, 0, 2) != "./")
     3250              && (substr($p_remove_dir, 0, 2) == "./")) {
     3251            $p_remove_dir = substr($p_remove_dir, 2);
     3252          }
     3253        }
     3254
     3255        $v_compare = PclZipUtilPathInclusion($p_remove_dir,
     3256                                             $v_stored_filename);
     3257        if ($v_compare > 0) {
     3258          if ($v_compare == 2) {
     3259            $v_stored_filename = "";
     3260            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Path to remove is the current folder");
     3261          }
     3262          else {
     3263            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Remove path '$p_remove_dir' in file '$v_stored_filename'");
     3264            $v_stored_filename = substr($v_stored_filename,
     3265                                        strlen($p_remove_dir));
     3266            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Result is '$v_stored_filename'");
     3267          }
     3268        }
     3269      }
     3270     
     3271      // ----- Remove drive letter if any
     3272      $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
     3273     
     3274      // ----- Look for path to add
     3275      if ($p_add_dir != "") {
     3276        if (substr($p_add_dir, -1) == "/")
     3277          $v_stored_filename = $p_add_dir.$v_stored_filename;
     3278        else
     3279          $v_stored_filename = $p_add_dir."/".$v_stored_filename;
     3280        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Add path '$p_add_dir' in file '$p_filename' = '$v_stored_filename'");