Changeset 74815 in spip-zone for _dev_


Ignore:
Timestamp:
Aug 18, 2013, 4:00:49 PM (6 years ago)
Author:
gilles.vincent@…
Message:

Mise a jour des regles de commit et de pclzip

Location:
_dev_/spip_loader
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • _dev_/spip_loader/branches/v1.0/_REGLES_DE_COMMIT

    r74814 r74815  
    33=====================
    44
    5 Ouvert a toute modification correctrice ou evolutive sur le fichier spip_loader.php.txt.
     5Ouvert a toute modification correctrice ou evolutive sur le repertoire trunk/
    66
    7 Le fichier pclzip.php.txt ne subit de modification que si le fichier d'origine de spip évolue.
     7Le fichier pclzip.php ne subit de modification que si le fichier d'origine de spip évolue.
    88
    99Les fichiers de langue sont maintenues dans l'interface de traduction de spip.net (<http://www.spip.net/trad-lang/trad_lang.php> module: SPIP Loader) .
  • _dev_/spip_loader/trunk/_REGLES_DE_COMMIT

    r74814 r74815  
    33=====================
    44
    5 Ouvert a toute modification correctrice ou evolutive sur le fichier spip_loader.php.txt.
     5Ouvert a toute modification correctrice ou evolutive sur le repertoire trunk/
    66
    7 Le fichier pclzip.php.txt ne subit de modification que si le fichier d'origine de spip évolue.
     7Le fichier pclzip.php ne subit de modification que si le fichier d'origine de spip évolue.
    88
    99Les fichiers de langue sont maintenues dans l'interface de traduction de spip.net (<http://www.spip.net/trad-lang/trad_lang.php> module: SPIP Loader) .
  • _dev_/spip_loader/trunk/pclzip.php

    r74814 r74815  
    11<?php
    22// --------------------------------------------------------------------------------
    3 // PhpConcept Library - Zip Module 2.5
     3// PhpConcept Library - Zip Module 2.8.2
    44// --------------------------------------------------------------------------------
    5 // License GNU/LGPL - Vincent Blavet - March 2006
     5// License GNU/LGPL - Vincent Blavet - August 2009
    66// http://www.phpconcept.net
    77// --------------------------------------------------------------------------------
     
    2323//
    2424// --------------------------------------------------------------------------------
    25 // $Id: pclzip.php 7613 2006-10-12 20:53:52Z james@rezo.net $
     25// $Id: pclzip.php 19990 2012-11-03 12:57:57Z eric@smellup.net $
    2626// --------------------------------------------------------------------------------
    2727
    2828  // ----- Constants
    29   define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
     29  if (!defined('PCLZIP_READ_BLOCK_SIZE')) {
     30    define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
     31  }
    3032 
    3133  // ----- File list separator
     
    3941  //define( 'PCLZIP_SEPARATOR', ' ' );
    4042  // Recommanded values for smart separation of filenames.
    41   define( 'PCLZIP_SEPARATOR', ',' );
     43  if (!defined('PCLZIP_SEPARATOR')) {
     44    define( 'PCLZIP_SEPARATOR', ',' );
     45  }
    4246
    4347  // ----- Error configuration
     
    4650  //     you must ensure that you have included PclError library.
    4751  // [2,...] : reserved for futur use
    48   define( 'PCLZIP_ERROR_EXTERNAL', 0 );
     52  if (!defined('PCLZIP_ERROR_EXTERNAL')) {
     53    define( 'PCLZIP_ERROR_EXTERNAL', 0 );
     54  }
    4955
    5056  // ----- Optional static temporary directory
     
    5763  // define( 'PCLZIP_TEMPORARY_DIR', '/temp/' );
    5864  // define( 'PCLZIP_TEMPORARY_DIR', 'C:/Temp/' );
    59   define( 'PCLZIP_TEMPORARY_DIR', '' );
     65  if (!defined('PCLZIP_TEMPORARY_DIR')) {
     66    define( 'PCLZIP_TEMPORARY_DIR', _DIR_TMP );
     67  }
     68
     69  // ----- Optional threshold ratio for use of temporary files
     70  //       Pclzip sense the size of the file to add/extract and decide to
     71  //       use or not temporary file. The algorythm is looking for
     72  //       memory_limit of PHP and apply a ratio.
     73  //       threshold = memory_limit * ratio.
     74  //       Recommended values are under 0.5. Default 0.47.
     75  //       Samples :
     76  // define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.5 );
     77  if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {
     78    define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );
     79  }
    6080
    6181// --------------------------------------------------------------------------------
     
    6484
    6585  // ----- Global variables
    66   $g_pclzip_version = "2.5";
     86  $g_pclzip_version = "2.8.2";
    6787
    6888  // ----- Error codes
     
    127147  //define( 'PCLZIP_OPT_CRYPT', 77018 );
    128148  define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );
     149  define( 'PCLZIP_OPT_TEMP_FILE_THRESHOLD', 77020 );
     150  define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 ); // alias
     151  define( 'PCLZIP_OPT_TEMP_FILE_ON', 77021 );
     152  define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 ); // alias
     153  define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );
     154  define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 ); // alias
    129155 
    130156  // ----- File description attributes
     
    132158  define( 'PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002 );
    133159  define( 'PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003 );
     160  define( 'PCLZIP_ATT_FILE_MTIME', 79004 );
     161  define( 'PCLZIP_ATT_FILE_CONTENT', 79005 );
     162  define( 'PCLZIP_ATT_FILE_COMMENT', 79006 );
    134163
    135164  // ----- Call backs values
     
    186215  function PclZip($p_zipname)
    187216  {
    188     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::PclZip', "zipname=$p_zipname");
    189217
    190218    // ----- Tests the zlib
    191219    if (!function_exists('gzopen'))
    192220    {
    193       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 1, "zlib extension seems to be missing");
    194221      die('Abort '.basename(__FILE__).' : Missing zlib extensions');
    195222    }
     
    201228
    202229    // ----- Return
    203     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 1);
    204230    return;
    205231  }
     
    245271  function create($p_filelist)
    246272  {
    247     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::create', "filelist='$p_filelist', ...");
    248273    $v_result=1;
    249274
     
    257282    // ----- Look for variable options arguments
    258283    $v_size = func_num_args();
    259     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    260284
    261285    // ----- Look for arguments
     
    270294      // ----- Look for first arg
    271295      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    272         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options detected");
    273296
    274297        // ----- Parse the options
     
    280303                                                   PCLZIP_CB_POST_ADD => 'optional',
    281304                                                   PCLZIP_OPT_NO_COMPRESSION => 'optional',
    282                                                    PCLZIP_OPT_COMMENT => 'optional'
     305                                                   PCLZIP_OPT_COMMENT => 'optional',
     306                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     307                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     308                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    283309                                                   //, PCLZIP_OPT_CRYPT => 'optional'
    284310                                             ));
    285311        if ($v_result != 1) {
    286           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    287312          return 0;
    288313        }
     
    293318      // method.
    294319      else {
    295         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    296320
    297321        // ----- Get the first argument
     
    305329          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
    306330                                       "Invalid number / type of arguments");
    307           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    308331          return 0;
    309332        }
    310333      }
    311334    }
     335   
     336    // ----- Look for default option values
     337    $this->privOptionDefaultThreshold($v_options);
    312338
    313339    // ----- Init
     
    341367    else {
    342368      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
    343       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    344369      return 0;
    345370    }
     
    352377        }
    353378        else {
    354           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Ignore an empty filename");
    355379        }
    356380      }
     
    362386             ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
    363387             ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
     388             ,PCLZIP_ATT_FILE_MTIME => 'optional'
     389             ,PCLZIP_ATT_FILE_CONTENT => 'optional'
     390             ,PCLZIP_ATT_FILE_COMMENT => 'optional'
    364391                                                );
    365392    foreach ($v_att_list as $v_entry) {
     
    369396                                               $v_supported_attributes);
    370397      if ($v_result != 1) {
    371         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    372398        return 0;
    373399      }
     
    377403    $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
    378404    if ($v_result != 1) {
    379       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    380405      return 0;
    381406    }
     
    384409    $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);
    385410    if ($v_result != 1) {
    386       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    387411      return 0;
    388412    }
    389413
    390414    // ----- Return
    391     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_result_list);
    392415    return $p_result_list;
    393416  }
     
    431454  function add($p_filelist)
    432455  {
    433     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::add', "filelist='$p_filelist', ...");
    434456    $v_result=1;
    435457
     
    443465    // ----- Look for variable options arguments
    444466    $v_size = func_num_args();
    445     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    446467
    447468    // ----- Look for arguments
     
    456477      // ----- Look for first arg
    457478      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    458         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options detected");
    459479
    460480        // ----- Parse the options
     
    468488                                                   PCLZIP_OPT_COMMENT => 'optional',
    469489                                                   PCLZIP_OPT_ADD_COMMENT => 'optional',
    470                                                    PCLZIP_OPT_PREPEND_COMMENT => 'optional'
     490                                                   PCLZIP_OPT_PREPEND_COMMENT => 'optional',
     491                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     492                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     493                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    471494                                                   //, PCLZIP_OPT_CRYPT => 'optional'
    472495                                                                                                   ));
    473496        if ($v_result != 1) {
    474           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    475497          return 0;
    476498        }
     
    481503      // method.
    482504      else {
    483         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    484505
    485506        // ----- Get the first argument
     
    495516
    496517          // ----- Return
    497           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    498518          return 0;
    499519        }
    500520      }
    501521    }
     522
     523    // ----- Look for default option values
     524    $this->privOptionDefaultThreshold($v_options);
    502525
    503526    // ----- Init
     
    531554    else {
    532555      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
    533       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    534556      return 0;
    535557    }
     
    547569             ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
    548570             ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
     571             ,PCLZIP_ATT_FILE_MTIME => 'optional'
     572             ,PCLZIP_ATT_FILE_CONTENT => 'optional'
     573             ,PCLZIP_ATT_FILE_COMMENT => 'optional'
    549574                                                );
    550575    foreach ($v_att_list as $v_entry) {
     
    554579                                               $v_supported_attributes);
    555580      if ($v_result != 1) {
    556         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    557581        return 0;
    558582      }
     
    562586    $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
    563587    if ($v_result != 1) {
    564       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    565588      return 0;
    566589    }
     
    569592    $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);
    570593    if ($v_result != 1) {
    571       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    572594      return 0;
    573595    }
    574596
    575597    // ----- Return
    576     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_result_list);
    577598    return $p_result_list;
    578599  }
     
    607628  //                newer_exist : the file was not extracted because a newer file exists
    608629  //                path_creation_fail : the file is not extracted because the folder
    609   //                                     does not exists and can not be created
     630  //                                     does not exist and can not be created
    610631  //                write_error : the file was not extracted because there was a
    611632  //                              error while writing the file
     
    622643  function listContent()
    623644  {
    624     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::listContent', "");
    625645    $v_result=1;
    626646
     
    630650    // ----- Check archive
    631651    if (!$this->privCheckFormat()) {
    632       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    633652      return(0);
    634653    }
     
    639658    {
    640659      unset($p_list);
    641       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    642660      return(0);
    643661    }
    644662
    645663    // ----- Return
    646     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    647664    return $p_list;
    648665  }
     
    683700  function extract()
    684701  {
    685     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::extract", "");
    686702    $v_result=1;
    687703
     
    691707    // ----- Check archive
    692708    if (!$this->privCheckFormat()) {
    693       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    694709      return(0);
    695710    }
     
    704719    // ----- Look for variable options arguments
    705720    $v_size = func_num_args();
    706     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    707721
    708722    // ----- Default values for option
     
    716730      // ----- Look for first arg
    717731      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    718         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options");
    719732
    720733        // ----- Parse the options
     
    735748                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'
    736749                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
    737                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional'
     750                                                   ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
     751                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     752                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     753                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    738754                                                                                                    ));
    739755        if ($v_result != 1) {
    740           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    741756          return 0;
    742757        }
     
    765780      // method.
    766781      else {
    767         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    768782
    769783        // ----- Get the first argument
     
    779793
    780794          // ----- Return
    781           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    782795          return 0;
    783796        }
     
    785798    }
    786799
     800    // ----- Look for default option values
     801    $this->privOptionDefaultThreshold($v_options);
     802
    787803    // ----- Trace
    788     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "path='$v_path', remove_path='$v_remove_path', remove_all_path='".($v_remove_path?'true':'false')."'");
    789804
    790805    // ----- Call the extracting fct
     
    794809    if ($v_result < 1) {
    795810      unset($p_list);
    796       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    797811      return(0);
    798812    }
    799813
    800814    // ----- Return
    801     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    802815    return $p_list;
    803816  }
     
    844857  function extractByIndex($p_index)
    845858  {
    846     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::extractByIndex", "index='$p_index', ...");
    847859    $v_result=1;
    848860
     
    852864    // ----- Check archive
    853865    if (!$this->privCheckFormat()) {
    854       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    855866      return(0);
    856867    }
     
    865876    // ----- Look for variable options arguments
    866877    $v_size = func_num_args();
    867     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    868878
    869879    // ----- Default values for option
     
    881891      // ----- Look for first arg
    882892      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
    883         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Variable list of options");
    884893
    885894        // ----- Parse the options
     
    895904                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'
    896905                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
    897                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional'
     906                                                   ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
     907                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     908                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     909                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    898910                                                                                                   ));
    899911        if ($v_result != 1) {
    900           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    901912          return 0;
    902913        }
     
    921932        if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {
    922933          $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
    923           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Option PCLZIP_OPT_EXTRACT_AS_STRING not set.");
    924934        }
    925935        else {
    926             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Option PCLZIP_OPT_EXTRACT_AS_STRING set.");
    927936        }
    928937      }
     
    932941      // method.
    933942      else {
    934         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Static synopsis");
    935943
    936944        // ----- Get the first argument
     
    946954
    947955          // ----- Return
    948           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    949956          return 0;
    950957        }
     
    953960
    954961    // ----- Trace
    955     //--(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')."'");
    956962
    957963    // ----- Trick
     
    963969                                        array (PCLZIP_OPT_BY_INDEX => 'optional' ));
    964970    if ($v_result != 1) {
    965         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    966971        return 0;
    967972    }
    968973    $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
     974
     975    // ----- Look for default option values
     976    $this->privOptionDefaultThreshold($v_options);
    969977
    970978    // ----- Call the extracting fct
    971979    if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {
    972         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    973980        return(0);
    974981    }
    975982
    976983    // ----- Return
    977     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    978984    return $p_list;
    979985  }
     
    10001006  function delete()
    10011007  {
    1002     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::delete", "");
    10031008    $v_result=1;
    10041009
     
    10081013    // ----- Check archive
    10091014    if (!$this->privCheckFormat()) {
    1010       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    10111015      return(0);
    10121016    }
     
    10171021    // ----- Look for variable options arguments
    10181022    $v_size = func_num_args();
    1019     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "$v_size arguments passed to the method");
    10201023
    10211024    // ----- Look for arguments
     
    10311034                                               PCLZIP_OPT_BY_INDEX => 'optional' ));
    10321035      if ($v_result != 1) {
    1033           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    10341036          return 0;
    10351037      }
     
    10441046      $this->privSwapBackMagicQuotes();
    10451047      unset($v_list);
    1046       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0, PclZip::errorInfo());
    10471048      return(0);
    10481049    }
     
    10521053
    10531054    // ----- Return
    1054     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_list);
    10551055    return $v_list;
    10561056  }
     
    10651065  function deleteByIndex($p_index)
    10661066  {
    1067     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::deleteByIndex", "index='$p_index'");
    10681067   
    10691068    $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
    10701069
    10711070    // ----- Return
    1072     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $p_list);
    10731071    return $p_list;
    10741072  }
     
    10911089  function properties()
    10921090  {
    1093     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::properties", "");
    10941091
    10951092    // ----- Reset the error handler
     
    11021099    if (!$this->privCheckFormat()) {
    11031100      $this->privSwapBackMagicQuotes();
    1104       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    11051101      return(0);
    11061102    }
     
    11161112    {
    11171113      // ----- Open the zip file
    1118       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    11191114      if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
    11201115      {
     
    11251120
    11261121        // ----- Return
    1127         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), 0);
    11281122        return 0;
    11291123      }
     
    11341128      {
    11351129        $this->privSwapBackMagicQuotes();
    1136         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    11371130        return 0;
    11381131      }
     
    11511144
    11521145    // ----- Return
    1153     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_prop);
    11541146    return $v_prop;
    11551147  }
     
    11701162  function duplicate($p_archive)
    11711163  {
    1172     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::duplicate", "");
    11731164    $v_result = 1;
    11741165
     
    11791170    if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
    11801171    {
    1181       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The parameter is valid PclZip object '".$p_archive->zipname."'");
    11821172
    11831173      // ----- Duplicate the archive
     
    11881178    else if (is_string($p_archive))
    11891179    {
    1190       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The parameter is a filename '$p_archive'");
    11911180
    11921181      // ----- Check that $p_archive is a valid zip file
     
    12121201
    12131202    // ----- Return
    1214     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    12151203    return $v_result;
    12161204  }
     
    12331221  function merge($p_archive_to_add)
    12341222  {
    1235     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::merge", "");
    12361223    $v_result = 1;
    12371224
     
    12411228    // ----- Check archive
    12421229    if (!$this->privCheckFormat()) {
    1243       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, 0);
    12441230      return(0);
    12451231    }
     
    12481234    if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
    12491235    {
    1250       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The parameter is valid PclZip object");
    12511236
    12521237      // ----- Merge the archive
     
    12571242    else if (is_string($p_archive_to_add))
    12581243    {
    1259       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The parameter is a filename");
    12601244
    12611245      // ----- Create a temporary archive
     
    12751259
    12761260    // ----- Return
    1277     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    12781261    return $v_result;
    12791262  }
     
    13901373  function privCheckFormat($p_level=0)
    13911374  {
    1392     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCheckFormat", "");
    13931375    $v_result = true;
    13941376
     
    14031385      // ----- Error log
    14041386      PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
    1405       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, false, PclZip::errorInfo());
    14061387      return(false);
    14071388    }
     
    14111392      // ----- Error log
    14121393      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
    1413       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, false, PclZip::errorInfo());
    14141394      return(false);
    14151395    }
     
    14251405
    14261406    // ----- Return
    1427     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    14281407    return $v_result;
    14291408  }
     
    14471426  function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)
    14481427  {
    1449     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privParseOptions", "");
    14501428    $v_result=1;
    14511429   
     
    14531431    $i=0;
    14541432    while ($i<$p_size) {
    1455       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Looking for table index $i, option = '".PclZipUtilOptionText($p_options_list[$i])."(".$p_options_list[$i].")'");
    14561433
    14571434      // ----- Check if the option is supported
     
    14611438
    14621439        // ----- Return
    1463         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    14641440        return PclZip::errorCode();
    14651441      }
     
    14771453
    14781454            // ----- Return
    1479             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    14801455            return PclZip::errorCode();
    14811456          }
    14821457
    14831458          // ----- Get the value
    1484           $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], false);
    1485           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1459          $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
    14861460          $i++;
     1461        break;
     1462
     1463        case PCLZIP_OPT_TEMP_FILE_THRESHOLD :
     1464          // ----- Check the number of parameters
     1465          if (($i+1) >= $p_size) {
     1466            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1467            return PclZip::errorCode();
     1468          }
     1469         
     1470          // ----- Check for incompatible options
     1471          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
     1472            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
     1473            return PclZip::errorCode();
     1474          }
     1475         
     1476          // ----- Check the value
     1477          $v_value = $p_options_list[$i+1];
     1478          if ((!is_integer($v_value)) || ($v_value<0)) {
     1479            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Integer expected for option '".PclZipUtilOptionText($p_options_list[$i])."'");
     1480            return PclZip::errorCode();
     1481          }
     1482
     1483          // ----- Get the value (and convert it in bytes)
     1484          $v_result_list[$p_options_list[$i]] = $v_value*1048576;
     1485          $i++;
     1486        break;
     1487
     1488        case PCLZIP_OPT_TEMP_FILE_ON :
     1489          // ----- Check for incompatible options
     1490          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
     1491            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
     1492            return PclZip::errorCode();
     1493          }
     1494         
     1495          $v_result_list[$p_options_list[$i]] = true;
     1496        break;
     1497
     1498        case PCLZIP_OPT_TEMP_FILE_OFF :
     1499          // ----- Check for incompatible options
     1500          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_ON])) {
     1501            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_ON'");
     1502            return PclZip::errorCode();
     1503          }
     1504          // ----- Check for incompatible options
     1505          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
     1506            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_THRESHOLD'");
     1507            return PclZip::errorCode();
     1508          }
     1509         
     1510          $v_result_list[$p_options_list[$i]] = true;
    14871511        break;
    14881512
     
    14941518
    14951519            // ----- Return
    1496             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    14971520            return PclZip::errorCode();
    14981521          }
     
    15011524          if (   is_string($p_options_list[$i+1])
    15021525              && ($p_options_list[$i+1] != '')) {
    1503             $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], false);
    1504             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
     1526            $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
    15051527            $i++;
    15061528          }
    15071529          else {
    1508             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." set with an empty value is ignored.");
    15091530          }
    15101531        break;
     
    15181539
    15191540            // ----- Return
    1520             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15211541            return PclZip::errorCode();
    15221542          }
     
    15341554
    15351555            // ----- Return
    1536             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15371556            return PclZip::errorCode();
    15381557          }
    1539           ////--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    15401558          $i++;
    15411559        break;
     
    15431561        // ----- Look for options that request an EREG or PREG expression
    15441562        case PCLZIP_OPT_BY_EREG :
     1563          // ereg() is deprecated starting with PHP 5.3. Move PCLZIP_OPT_BY_EREG
     1564          // to PCLZIP_OPT_BY_PREG
     1565          $p_options_list[$i] = PCLZIP_OPT_BY_PREG;
    15451566        case PCLZIP_OPT_BY_PREG :
    15461567        //case PCLZIP_OPT_CRYPT :
     
    15511572
    15521573            // ----- Return
    1553             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15541574            return PclZip::errorCode();
    15551575          }
     
    15641584
    15651585            // ----- Return
    1566             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15671586            return PclZip::errorCode();
    15681587          }
    1569           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    15701588          $i++;
    15711589        break;
     
    15841602
    15851603            // ----- Return
    1586             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15871604            return PclZip::errorCode();
    15881605          }
     
    16001617
    16011618            // ----- Return
    1602             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    16031619            return PclZip::errorCode();
    16041620          }
    1605           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    16061621          $i++;
    16071622        break;
     
    16151630
    16161631            // ----- Return
    1617             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    16181632            return PclZip::errorCode();
    16191633          }
     
    16221636          $v_work_list = array();
    16231637          if (is_string($p_options_list[$i+1])) {
    1624               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is a string '".$p_options_list[$i+1]."'");
    16251638
    16261639              // ----- Remove spaces
     
    16311644          }
    16321645          else if (is_integer($p_options_list[$i+1])) {
    1633               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is an integer '".$p_options_list[$i+1]."'");
    16341646              $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];
    16351647          }
    16361648          else if (is_array($p_options_list[$i+1])) {
    1637               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Index value is an array");
    16381649              $v_work_list = $p_options_list[$i+1];
    16391650          }
     
    16431654
    16441655            // ----- Return
    1645             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    16461656            return PclZip::errorCode();
    16471657          }
     
    16771687
    16781688                  // ----- Return
    1679                   //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    16801689                  return PclZip::errorCode();
    16811690              }
    16821691
    1683               //--(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']."]");
    16841692
    16851693              // ----- Look for list sort
    16861694              if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
    1687                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The list should be sorted ...");
    16881695                  $v_sort_flag=true;
    16891696
     
    16931700
    16941701                  // ----- Return
    1695                   //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    16961702                  return PclZip::errorCode();
    16971703              }
     
    17021708          if ($v_sort_flag) {
    17031709              // TBC : To Be Completed
    1704               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "List sorting is not yet write ...");
    17051710          }
    17061711
     
    17171722        case PCLZIP_OPT_STOP_ON_ERROR :
    17181723          $v_result_list[$p_options_list[$i]] = true;
    1719           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    17201724        break;
    17211725
     
    17281732
    17291733            // ----- Return
    1730             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    17311734            return PclZip::errorCode();
    17321735          }
     
    17341737          // ----- Get the value
    17351738          $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
    1736           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($p_options_list[$i])." = '".$v_result_list[$p_options_list[$i]]."'");
    17371739          $i++;
    17381740        break;
     
    17551757
    17561758            // ----- Return
    1757             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    17581759            return PclZip::errorCode();
    17591760          }
     
    17611762          // ----- Get the value
    17621763          $v_function_name = $p_options_list[$i+1];
    1763           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "call-back ".PclZipUtilOptionText($p_options_list[$i])." = '".$v_function_name."'");
    17641764
    17651765          // ----- Check that the value is a valid existing function
     
    17691769
    17701770            // ----- Return
    1771             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    17721771            return PclZip::errorCode();
    17731772          }
     
    17851784
    17861785          // ----- Return
    1787           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    17881786          return PclZip::errorCode();
    17891787      }
     
    17981796        // ----- Look for mandatory option
    17991797        if ($v_requested_options[$key] == 'mandatory') {
    1800           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Detect a mandatory option : ".PclZipUtilOptionText($key)."(".$key.")");
    18011798          // ----- Look if present
    18021799          if (!isset($v_result_list[$key])) {
     
    18051802
    18061803            // ----- Return
    1807             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18081804            return PclZip::errorCode();
    18091805          }
     
    18111807      }
    18121808    }
     1809   
     1810    // ----- Look for default values
     1811    if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
     1812     
     1813    }
    18131814
    18141815    // ----- Return
    1815     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     1816    return $v_result;
     1817  }
     1818  // --------------------------------------------------------------------------------
     1819
     1820  // --------------------------------------------------------------------------------
     1821  // Function : privOptionDefaultThreshold()
     1822  // Description :
     1823  // Parameters :
     1824  // Return Values :
     1825  // --------------------------------------------------------------------------------
     1826  function privOptionDefaultThreshold(&$p_options)
     1827  {
     1828    $v_result=1;
     1829   
     1830    if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     1831        || isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) {
     1832      return $v_result;
     1833    }
     1834   
     1835    // ----- Get 'memory_limit' configuration value
     1836    $v_memory_limit = ini_get('memory_limit');
     1837    $v_memory_limit = trim($v_memory_limit);
     1838    $last = strtolower(substr($v_memory_limit, -1));
     1839 
     1840    if($last == 'g')
     1841        //$v_memory_limit = $v_memory_limit*1024*1024*1024;
     1842        $v_memory_limit = $v_memory_limit*1073741824;
     1843    if($last == 'm')
     1844        //$v_memory_limit = $v_memory_limit*1024*1024;
     1845        $v_memory_limit = $v_memory_limit*1048576;
     1846    if($last == 'k')
     1847        $v_memory_limit = $v_memory_limit*1024;
     1848           
     1849    $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO);
     1850   
     1851
     1852    // ----- Sanity check : No threshold if value lower than 1M
     1853    if ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] < 1048576) {
     1854      unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
     1855    }
     1856         
     1857    // ----- Return
    18161858    return $v_result;
    18171859  }
     
    18281870  function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)
    18291871  {
    1830     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privFileDescrParseAtt", "");
    18311872    $v_result=1;
    18321873   
     
    18401881
    18411882        // ----- Return
    1842         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18431883        return PclZip::errorCode();
    18441884      }
     
    18491889          if (!is_string($v_value)) {
    18501890            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
    1851             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18521891            return PclZip::errorCode();
    18531892          }
    18541893
    18551894          $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
    1856           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
    18571895         
    18581896          if ($p_filedescr['filename'] == '') {
    18591897            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
    1860             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18611898            return PclZip::errorCode();
    18621899          }
     
    18671904          if (!is_string($v_value)) {
    18681905            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
    1869             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18701906            return PclZip::errorCode();
    18711907          }
    18721908
    18731909          $p_filedescr['new_short_name'] = PclZipUtilPathReduction($v_value);
    1874           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
    18751910
    18761911          if ($p_filedescr['new_short_name'] == '') {
    18771912            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");
    1878             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18791913            return PclZip::errorCode();
    18801914          }
     
    18841918          if (!is_string($v_value)) {
    18851919            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
    1886             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18871920            return PclZip::errorCode();
    18881921          }
    18891922
    18901923          $p_filedescr['new_full_name'] = PclZipUtilPathReduction($v_value);
    1891           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "".PclZipUtilOptionText($v_key)." = '".$v_value."'");
    18921924
    18931925          if ($p_filedescr['new_full_name'] == '') {
    18941926            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");
    1895             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    18961927            return PclZip::errorCode();
    18971928          }
     1929        break;
     1930
     1931        // ----- Look for options that takes a string
     1932        case PCLZIP_ATT_FILE_COMMENT :
     1933          if (!is_string($v_value)) {
     1934            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1935            return PclZip::errorCode();
     1936          }
     1937
     1938          $p_filedescr['comment'] = $v_value;
     1939        break;
     1940
     1941        case PCLZIP_ATT_FILE_MTIME :
     1942          if (!is_integer($v_value)) {
     1943            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". Integer expected for attribute '".PclZipUtilOptionText($v_key)."'");
     1944            return PclZip::errorCode();
     1945          }
     1946
     1947          $p_filedescr['mtime'] = $v_value;
     1948        break;
     1949
     1950        case PCLZIP_ATT_FILE_CONTENT :
     1951          $p_filedescr['content'] = $v_value;
    18981952        break;
    18991953
     
    19041958
    19051959          // ----- Return
    1906           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    19071960          return PclZip::errorCode();
    19081961      }
     
    19131966          // ----- Look for mandatory option
    19141967          if ($v_requested_options[$key] == 'mandatory') {
    1915             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Detect a mandatory option : ".PclZipUtilOptionText($key)."(".$key.")");
    19161968            // ----- Look if present
    19171969            if (!isset($p_file_list[$key])) {
    19181970              PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
    1919               //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    19201971              return PclZip::errorCode();
    19211972            }
     
    19281979   
    19291980    // ----- Return
    1930     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    19311981    return $v_result;
    19321982  }
     
    19361986  // Function : privFileDescrExpand()
    19371987  // Description :
     1988  //   This method look for each item of the list to see if its a file, a folder
     1989  //   or a string to be added as file. For any other type of files (link, other)
     1990  //   just ignore the item.
     1991  //   Then prepare the information that will be stored for that file.
     1992  //   When its a folder, expand the folder with all the files that are in that
     1993  //   folder (recursively).
    19381994  // Parameters :
    19391995  // Return Values :
     
    19431999  function privFileDescrExpand(&$p_filedescr_list, &$p_options)
    19442000  {
    1945     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privFileDescrExpand", "");
    19462001    $v_result=1;
    19472002   
     
    19512006    // ----- Look each entry
    19522007    for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
     2008     
    19532009      // ----- Get filedescr
    19542010      $v_descr = $p_filedescr_list[$i];
    19552011     
    19562012      // ----- Reduce the filename
    1957       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filedescr before reduction :'".$v_descr['filename']."'");
    1958       $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename']);
     2013      $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
    19592014      $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
    1960       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filedescr after reduction :'".$v_descr['filename']."'");
    19612015     
    1962       // ----- Get type of descr
    1963       if (!file_exists($v_descr['filename'])) {
     2016      // ----- Look for real file or folder
     2017      if (file_exists($v_descr['filename'])) {
     2018        if (@is_file($v_descr['filename'])) {
     2019          $v_descr['type'] = 'file';
     2020        }
     2021        else if (@is_dir($v_descr['filename'])) {
     2022          $v_descr['type'] = 'folder';
     2023        }
     2024        else if (@is_link($v_descr['filename'])) {
     2025          // skip
     2026          continue;
     2027        }
     2028        else {
     2029          // skip
     2030          continue;
     2031        }
     2032      }
     2033     
     2034      // ----- Look for string added as file
     2035      else if (isset($v_descr['content'])) {
     2036        $v_descr['type'] = 'virtual_file';
     2037      }
     2038     
     2039      // ----- Missing file
     2040      else {
    19642041        // ----- Error log
    1965         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$v_descr['filename']."' does not exists");
    1966         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exists");
     2042        PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exist");
    19672043
    19682044        // ----- Return
    1969         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    19702045        return PclZip::errorCode();
    1971       }
    1972       if (@is_file($v_descr['filename'])) {
    1973         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "This is a file");
    1974         $v_descr['type'] = 'file';
    1975       }
    1976       else if (@is_dir($v_descr['filename'])) {
    1977         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "This is a folder");
    1978         $v_descr['type'] = 'folder';
    1979       }
    1980       else if (@is_link($v_descr['filename'])) {
    1981         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Unsupported file type : link");
    1982         // skip
    1983         continue;
    1984       }
    1985       else {
    1986         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Unsupported file type : unknown type");
    1987         // skip
    1988         continue;
    19892046      }
    19902047     
     
    20022059        if ($v_folder_handler = @opendir($v_descr['filename'])) {
    20032060          while (($v_item_handler = @readdir($v_folder_handler)) !== false) {
    2004             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Looking for '".$v_item_handler."' in the directory");
    20052061
    20062062            // ----- Skip '.' and '..'
     
    20152071            // Because the name of the folder was changed, the name of the
    20162072            // files/sub-folders also change
    2017             if ($v_descr['stored_filename'] != $v_descr['filename']) {
    2018               $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
     2073            if (($v_descr['stored_filename'] != $v_descr['filename'])
     2074                 && (!isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))) {
     2075              if ($v_descr['stored_filename'] != '') {
     2076                $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
     2077              }
     2078              else {
     2079                $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_item_handler;
     2080              }
    20192081            }
    20202082     
    20212083            $v_dirlist_nb++;
    20222084          }
     2085         
     2086          @closedir($v_folder_handler);
    20232087        }
    20242088        else {
    2025           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to open dir '".$v_descr['filename']."' in read mode. Skipped.");
    20262089          // TBC : unable to open folder in read mode
    20272090        }
     
    20312094          // ----- Expand
    20322095          if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {
    2033             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    20342096            return $v_result;
    20352097          }
    20362098         
    20372099          // ----- Concat the resulting list
    2038           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Merging result list (size '".sizeof($v_result_list)."') with dirlist (size '".sizeof($v_dirlist_descr)."')");
    20392100          $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
    2040           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "merged result list is size '".sizeof($v_result_list)."'");
    20412101        }
    20422102        else {
    2043           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Nothing in this folder to expand.");
    20442103        }
    20452104         
     
    20532112
    20542113    // ----- Return
    2055     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    20562114    return $v_result;
    20572115  }
     
    20662124  function privCreate($p_filedescr_list, &$p_result_list, &$p_options)
    20672125  {
    2068     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCreate", "list");
    20692126    $v_result=1;
    20702127    $v_list_detail = array();
     
    20772134    {
    20782135      // ----- Return
    2079       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    20802136      return $v_result;
    20812137    }
     
    20912147
    20922148    // ----- Return
    2093     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    20942149    return $v_result;
    20952150  }
     
    21042159  function privAdd($p_filedescr_list, &$p_result_list, &$p_options)
    21052160  {
    2106     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAdd", "list");
    21072161    $v_result=1;
    21082162    $v_list_detail = array();
     
    21112165    if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0))
    21122166    {
    2113       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Archive does not exist, or is empty, create it.");
    21142167
    21152168      // ----- Do a create
     
    21172170
    21182171      // ----- Return
    2119       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    21202172      return $v_result;
    21212173    }
     
    21242176
    21252177    // ----- Open the zip file
    2126     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    21272178    if (($v_result=$this->privOpenFd('rb')) != 1)
    21282179    {
     
    21312182
    21322183      // ----- Return
    2133       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    21342184      return $v_result;
    21352185    }
     
    21412191      $this->privCloseFd();
    21422192      $this->privSwapBackMagicQuotes();
    2143       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    21442193      return $v_result;
    21452194    }
    21462195
    21472196    // ----- Go to beginning of File
    2148     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
    21492197    @rewind($this->zip_fd);
    2150     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
    21512198
    21522199    // ----- Creates a temporay file
     
    21542201
    21552202    // ----- Open the temporary file in write mode
    2156     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    21572203    if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
    21582204    {
     
    21632209
    21642210      // ----- Return
    2165       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    21662211      return PclZip::errorCode();
    21672212    }
     
    21732218    {
    21742219      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    2175       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    21762220      $v_buffer = fread($this->zip_fd, $v_read_size);
    21772221      @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
     
    21962240
    21972241      // ----- Return
    2198       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    21992242      return $v_result;
    22002243    }
     
    22022245    // ----- Store the offset of the central dir
    22032246    $v_offset = @ftell($this->zip_fd);
    2204     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "New offset of central dir : $v_offset");
    22052247
    22062248    // ----- Copy the block of file headers from the old archive
     
    22092251    {
    22102252      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    2211       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    22122253      $v_buffer = @fread($v_zip_temp_fd, $v_read_size);
    22132254      @fwrite($this->zip_fd, $v_buffer, $v_read_size);
     
    22272268
    22282269          // ----- Return
    2229           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    22302270          return $v_result;
    22312271        }
     
    22602300
    22612301      // ----- Return
    2262       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    22632302      return $v_result;
    22642303    }
     
    22882327
    22892328    // ----- Return
    2290     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    22912329    return $v_result;
    22922330  }
     
    23002338  function privOpenFd($p_mode)
    23012339  {
    2302     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privOpenFd", 'mode='.$p_mode);
    23032340    $v_result=1;
    23042341
     
    23102347
    23112348      // ----- Return
    2312       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    23132349      return PclZip::errorCode();
    23142350    }
    23152351
    23162352    // ----- Open the zip file
    2317     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Open file in '.$p_mode.' mode');
    23182353    if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
    23192354    {
     
    23222357
    23232358      // ----- Return
    2324       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    23252359      return PclZip::errorCode();
    23262360    }
    23272361
    23282362    // ----- Return
    2329     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    23302363    return $v_result;
    23312364  }
     
    23392372  function privCloseFd()
    23402373  {
    2341     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCloseFd", "");
    23422374    $v_result=1;
    23432375
     
    23472379
    23482380    // ----- Return
    2349     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    23502381    return $v_result;
    23512382  }
     
    23682399  function privAddList($p_filedescr_list, &$p_result_list, &$p_options)
    23692400  {
    2370     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddList", "list");
    23712401    $v_result=1;
    23722402
     
    23762406    {
    23772407      // ----- Return
    2378       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    23792408      return $v_result;
    23802409    }
     
    23902419        if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
    23912420          // ----- Return
    2392           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    23932421          return $v_result;
    23942422        }
     
    24162444
    24172445      // ----- Return
    2418       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    24192446      return $v_result;
    24202447    }
    24212448
    24222449    // ----- Return
    2423     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    24242450    return $v_result;
    24252451  }
     
    24372463  function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options)
    24382464  {
    2439     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddFileList", "filedescr_list");
    24402465    $v_result=1;
    24412466    $v_header = array();
     
    24432468    // ----- Recuperate the current number of elt in list
    24442469    $v_nb = sizeof($p_result_list);
    2445     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Before add, list have ".$v_nb." elements");
    24462470
    24472471    // ----- Loop on the files
     
    24512475      = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
    24522476     
    2453       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Looking for file '".$p_filedescr_list[$j]['filename']."'");
    24542477
    24552478      // ----- Skip empty file names
    24562479      // TBC : Can this be possible ? not checked in DescrParseAtt ?
    24572480      if ($p_filedescr_list[$j]['filename'] == "") {
    2458         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Skip empty filename");
    24592481        continue;
    24602482      }
    24612483
    24622484      // ----- Check the filename
    2463       if (!file_exists($p_filedescr_list[$j]['filename'])) {
    2464         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$p_filedescr_list[$j]['filename']."' does not exists");
    2465         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exists");
    2466         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     2485      if (   ($p_filedescr_list[$j]['type'] != 'virtual_file')
     2486          && (!file_exists($p_filedescr_list[$j]['filename']))) {
     2487        PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exist");
    24672488        return PclZip::errorCode();
    24682489      }
    24692490
    24702491      // ----- Look if it is a file or a dir with no all path remove option
    2471       if (   (is_file($p_filedescr_list[$j]['filename']))
    2472           || (   is_dir($p_filedescr_list[$j]['filename'])
     2492      // or a dir with all its path removed
     2493//      if (   (is_file($p_filedescr_list[$j]['filename']))
     2494//          || (   is_dir($p_filedescr_list[$j]['filename'])
     2495      if (   ($p_filedescr_list[$j]['type'] == 'file')
     2496          || ($p_filedescr_list[$j]['type'] == 'virtual_file')
     2497          || (   ($p_filedescr_list[$j]['type'] == 'folder')
    24732498              && (   !isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
    2474                   || !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))) {
     2499                  || !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))
     2500          ) {
    24752501
    24762502        // ----- Add the file
     
    24782504                                       $p_options);
    24792505        if ($v_result != 1) {
    2480           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    24812506          return $v_result;
    24822507        }
     
    24862511      }
    24872512    }
    2488     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "After add, list have ".$v_nb." elements");
    24892513
    24902514    // ----- Return
    2491     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    24922515    return $v_result;
    24932516  }
     
    25022525  function privAddFile($p_filedescr, &$p_header, &$p_options)
    25032526  {
    2504     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privAddFile", "filename='".$p_filedescr['filename']."'");
    25052527    $v_result=1;
    25062528   
     
    25142536
    25152537      // ----- Return
    2516       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    25172538      return PclZip::errorCode();
    25182539    }
    25192540 
    25202541    // ----- Look for a stored different filename
     2542    /* TBC : Removed
    25212543    if (isset($p_filedescr['stored_filename'])) {
    25222544      $v_stored_filename = $p_filedescr['stored_filename'];
    2523       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'Stored filename is NOT the same "'.$v_stored_filename.'"');
    25242545    }
    25252546    else {
    25262547      $v_stored_filename = $p_filedescr['stored_filename'];
    2527       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'Stored filename is the same');
    2528     }
     2548    }
     2549    */
    25292550
    25302551    // ----- Set the file properties
     
    25342555    $p_header['flag'] = 0;
    25352556    $p_header['compression'] = 0;
    2536     $p_header['mtime'] = filemtime($p_filename);
    25372557    $p_header['crc'] = 0;
    25382558    $p_header['compressed_size'] = 0;
    2539     $p_header['size'] = filesize($p_filename);
    25402559    $p_header['filename_len'] = strlen($p_filename);
    25412560    $p_header['extra_len'] = 0;
    2542     $p_header['comment_len'] = 0;
    25432561    $p_header['disk'] = 0;
    25442562    $p_header['internal'] = 0;
    2545 //    $p_header['external'] = (is_file($p_filename)?0xFE49FFE0:0x41FF0010);
    2546     $p_header['external'] = (is_file($p_filename)?0x00000000:0x00000010);
    2547     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Header external extension '".sprintf("0x%X",$p_header['external'])."'");
    25482563    $p_header['offset'] = 0;
    25492564    $p_header['filename'] = $p_filename;
    2550     $p_header['stored_filename'] = $v_stored_filename;
     2565// TBC : Removed    $p_header['stored_filename'] = $v_stored_filename;
     2566    $p_header['stored_filename'] = $p_filedescr['stored_filename'];
    25512567    $p_header['extra'] = '';
    2552     $p_header['comment'] = '';
    25532568    $p_header['status'] = 'ok';
    25542569    $p_header['index'] = -1;
    25552570
     2571    // ----- Look for regular file
     2572    if ($p_filedescr['type']=='file') {
     2573      $p_header['external'] = 0x00000000;
     2574      $p_header['size'] = filesize($p_filename);
     2575    }
     2576   
     2577    // ----- Look for regular folder
     2578    else if ($p_filedescr['type']=='folder') {
     2579      $p_header['external'] = 0x00000010;
     2580      $p_header['mtime'] = filemtime($p_filename);
     2581      $p_header['size'] = filesize($p_filename);
     2582    }
     2583   
     2584    // ----- Look for virtual file
     2585    else if ($p_filedescr['type'] == 'virtual_file') {
     2586      $p_header['external'] = 0x00000000;
     2587      $p_header['size'] = strlen($p_filedescr['content']);
     2588    }
     2589   
     2590
     2591    // ----- Look for filetime
     2592    if (isset($p_filedescr['mtime'])) {
     2593      $p_header['mtime'] = $p_filedescr['mtime'];
     2594    }
     2595    else if ($p_filedescr['type'] == 'virtual_file') {
     2596      $p_header['mtime'] = time();
     2597    }
     2598    else {
     2599      $p_header['mtime'] = filemtime($p_filename);
     2600    }
     2601
     2602    // ------ Look for file comment
     2603    if (isset($p_filedescr['comment'])) {
     2604      $p_header['comment_len'] = strlen($p_filedescr['comment']);
     2605      $p_header['comment'] = $p_filedescr['comment'];
     2606    }
     2607    else {
     2608      $p_header['comment_len'] = 0;
     2609      $p_header['comment'] = '';
     2610    }
     2611
    25562612    // ----- Look for pre-add callback
    25572613    if (isset($p_options[PCLZIP_CB_PRE_ADD])) {
    2558       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A pre-callback '".$p_options[PCLZIP_CB_PRE_ADD]."()') is defined for the extraction");
    25592614
    25602615      // ----- Generate a local information
     
    25652620      // Here I do not use call_user_func() because I need to send a reference to the
    25662621      // header.
    2567       eval('$v_result = '.$p_options[PCLZIP_CB_PRE_ADD].'(PCLZIP_CB_PRE_ADD, $v_local_header);');
     2622//      eval('$v_result = '.$p_options[PCLZIP_CB_PRE_ADD].'(PCLZIP_CB_PRE_ADD, $v_local_header);');
     2623      $v_result = $p_options[PCLZIP_CB_PRE_ADD](PCLZIP_CB_PRE_ADD, $v_local_header);
    25682624      if ($v_result == 0) {
    25692625        // ----- Change the file status
     
    25762632      if ($p_header['stored_filename'] != $v_local_header['stored_filename']) {
    25772633        $p_header['stored_filename'] = PclZipUtilPathReduction($v_local_header['stored_filename']);
    2578         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "New stored filename is '".$p_header['stored_filename']."'");
    25792634      }
    25802635    }
     
    25942649
    25952650      // ----- Look for a file
    2596       if (is_file($p_filename))
    2597       {
    2598         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a file");
     2651      if ($p_filedescr['type'] == 'file') {
     2652        // ----- Look for using temporary file to zip
     2653        if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
     2654            && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
     2655                || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     2656                    && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
     2657          $v_result = $this->privAddFileUsingTempFile($p_filedescr, $p_header, $p_options);
     2658          if ($v_result < PCLZIP_ERR_NO_ERROR) {
     2659            return $v_result;
     2660          }
     2661        }
     2662       
     2663        // ----- Use "in memory" zip algo
     2664        else {
     2665
    25992666        // ----- Open the source file
    26002667        if (($v_file = @fopen($p_filename, "rb")) == 0) {
    26012668          PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
    2602           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    26032669          return PclZip::errorCode();
    26042670        }
    26052671
     2672        // ----- Read the file content
     2673        $v_content = @fread($v_file, $p_header['size']);
     2674
     2675        // ----- Close the file
     2676        @fclose($v_file);
     2677
     2678        // ----- Calculate the CRC
     2679        $p_header['crc'] = @crc32($v_content);
     2680       
     2681        // ----- Look for no compression
    26062682        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
    2607           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will not be compressed");
    2608           // ----- Read the file content
    2609           $v_content_compressed = @fread($v_file, $p_header['size']);
    2610 
    2611           // ----- Calculate the CRC
    2612           $p_header['crc'] = @crc32($v_content_compressed);
    2613 
    26142683          // ----- Set header parameters
    26152684          $p_header['compressed_size'] = $p_header['size'];
    26162685          $p_header['compression'] = 0;
    26172686        }
     2687       
     2688        // ----- Look for normal compression
    26182689        else {
    2619           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will be compressed");
    2620           // ----- Read the file content
    2621           $v_content = @fread($v_file, $p_header['size']);
    2622 
    2623           // ----- Calculate the CRC
    2624           $p_header['crc'] = @crc32($v_content);
    2625 
    2626           // ----- Compress the file
    2627           $v_content_compressed = @gzdeflate($v_content);
     2690          // ----- Compress the content
     2691          $v_content = @gzdeflate($v_content);
    26282692
    26292693          // ----- Set header parameters
    2630           $p_header['compressed_size'] = strlen($v_content_compressed);
     2694          $p_header['compressed_size'] = strlen($v_content);
    26312695          $p_header['compression'] = 8;
    26322696        }
    26332697       
    2634         // ----- Look for encryption
    2635         /*
    2636         if ((isset($p_options[PCLZIP_OPT_CRYPT]))
    2637                     && ($p_options[PCLZIP_OPT_CRYPT] != "")) {
    2638           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File need to be crypted ....");
    2639          
    2640           // Should be a random header
    2641           $v_header = 'xxxxxxxxxxxx';
    2642               $v_content_compressed = PclZipUtilZipEncrypt($v_content_compressed,
    2643                                                            $p_header['compressed_size'],
    2644                                                        $v_header,
    2645                                                                                                    $p_header['crc'],
    2646                                                                                                    "test");
    2647                                                                                                    
    2648           $p_header['compressed_size'] += 12;
    2649           $p_header['flag'] = 1;
    2650          
    2651           // ----- Add the header to the data
    2652           $v_content_compressed = $v_header.$v_content_compressed;
    2653           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size after header : ".strlen($v_content_compressed)."");
    2654         }
    2655         */
    2656 
    26572698        // ----- Call the header generation
    26582699        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
    26592700          @fclose($v_file);
    2660           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    26612701          return $v_result;
    26622702        }
    26632703
    26642704        // ----- Write the compressed (or not) content
    2665         @fwrite($this->zip_fd,
    2666                             $v_content_compressed, $p_header['compressed_size']);
     2705        @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
     2706
     2707        }
     2708
     2709      }
     2710
     2711      // ----- Look for a virtual file (a file from string)
     2712      else if ($p_filedescr['type'] == 'virtual_file') {
     2713         
     2714        $v_content = $p_filedescr['content'];
     2715
     2716        // ----- Calculate the CRC
     2717        $p_header['crc'] = @crc32($v_content);
    26672718       
    2668         // ----- Close the file
    2669         @fclose($v_file);
     2719        // ----- Look for no compression
     2720        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
     2721          // ----- Set header parameters
     2722          $p_header['compressed_size'] = $p_header['size'];
     2723          $p_header['compression'] = 0;
     2724        }
     2725       
     2726        // ----- Look for normal compression
     2727        else {
     2728          // ----- Compress the content
     2729          $v_content = @gzdeflate($v_content);
     2730
     2731          // ----- Set header parameters
     2732          $p_header['compressed_size'] = strlen($v_content);
     2733          $p_header['compression'] = 8;
     2734        }
     2735       
     2736        // ----- Call the header generation
     2737        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     2738          @fclose($v_file);
     2739          return $v_result;
     2740        }
     2741
     2742        // ----- Write the compressed (or not) content
     2743        @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
    26702744      }
    26712745
    26722746      // ----- Look for a directory
    2673       else {
    2674         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a folder");
     2747      else if ($p_filedescr['type'] == 'folder') {
    26752748        // ----- Look for directory last '/'
    26762749        if (@substr($p_header['stored_filename'], -1) != '/') {
     
    26862759        if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
    26872760        {
    2688           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    26892761          return $v_result;
    26902762        }
     
    26942766    // ----- Look for post-add callback
    26952767    if (isset($p_options[PCLZIP_CB_POST_ADD])) {
    2696       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A post-callback '".$p_options[PCLZIP_CB_POST_ADD]."()') is defined for the extraction");
    26972768
    26982769      // ----- Generate a local information
     
    27032774      // Here I do not use call_user_func() because I need to send a reference to the
    27042775      // header.
    2705       eval('$v_result = '.$p_options[PCLZIP_CB_POST_ADD].'(PCLZIP_CB_POST_ADD, $v_local_header);');
     2776//      eval('$v_result = '.$p_options[PCLZIP_CB_POST_ADD].'(PCLZIP_CB_POST_ADD, $v_local_header);');
     2777      $v_result = $p_options[PCLZIP_CB_POST_ADD](PCLZIP_CB_POST_ADD, $v_local_header);
    27062778      if ($v_result == 0) {
    27072779        // ----- Ignored
     
    27142786
    27152787    // ----- Return
    2716     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     2788    return $v_result;
     2789  }
     2790  // --------------------------------------------------------------------------------
     2791
     2792  // --------------------------------------------------------------------------------
     2793  // Function : privAddFileUsingTempFile()
     2794  // Description :
     2795  // Parameters :
     2796  // Return Values :
     2797  // --------------------------------------------------------------------------------
     2798  function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options)
     2799  {
     2800    $v_result=PCLZIP_ERR_NO_ERROR;
     2801   
     2802    // ----- Working variable
     2803    $p_filename = $p_filedescr['filename'];
     2804
     2805
     2806    // ----- Open the source file
     2807    if (($v_file = @fopen($p_filename, "rb")) == 0) {
     2808      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
     2809      return PclZip::errorCode();
     2810    }
     2811
     2812    // ----- Creates a compressed temporary file
     2813    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
     2814    if (($v_file_compressed = @gzopen($v_gzip_temp_name, "wb")) == 0) {
     2815      fclose($v_file);
     2816      PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
     2817      return PclZip::errorCode();
     2818    }
     2819
     2820    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     2821    $v_size = filesize($p_filename);
     2822    while ($v_size != 0) {
     2823      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     2824      $v_buffer = @fread($v_file, $v_read_size);
     2825      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     2826      @gzputs($v_file_compressed, $v_buffer, $v_read_size);
     2827      $v_size -= $v_read_size;
     2828    }
     2829
     2830    // ----- Close the file
     2831    @fclose($v_file);
     2832    @gzclose($v_file_compressed);
     2833
     2834    // ----- Check the minimum file size
     2835    if (filesize($v_gzip_temp_name) < 18) {
     2836      PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'gzip temporary file \''.$v_gzip_temp_name.'\' has invalid filesize - should be minimum 18 bytes');
     2837      return PclZip::errorCode();
     2838    }
     2839
     2840    // ----- Extract the compressed attributes
     2841    if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0) {
     2842      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     2843      return PclZip::errorCode();
     2844    }
     2845
     2846    // ----- Read the gzip file header
     2847    $v_binary_data = @fread($v_file_compressed, 10);
     2848    $v_data_header = unpack('a1id1/a1id2/a1cm/a1flag/Vmtime/a1xfl/a1os', $v_binary_data);
     2849
     2850    // ----- Check some parameters
     2851    $v_data_header['os'] = bin2hex($v_data_header['os']);
     2852
     2853    // ----- Read the gzip file footer
     2854    @fseek($v_file_compressed, filesize($v_gzip_temp_name)-8);
     2855    $v_binary_data = @fread($v_file_compressed, 8);
     2856    $v_data_footer = unpack('Vcrc/Vcompressed_size', $v_binary_data);
     2857
     2858    // ----- Set the attributes
     2859    $p_header['compression'] = ord($v_data_header['cm']);
     2860    //$p_header['mtime'] = $v_data_header['mtime'];
     2861    $p_header['crc'] = $v_data_footer['crc'];
     2862    $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;
     2863
     2864    // ----- Close the file
     2865    @fclose($v_file_compressed);
     2866
     2867    // ----- Call the header generation
     2868    if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     2869      return $v_result;
     2870    }
     2871
     2872    // ----- Add the compressed data
     2873    if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0)
     2874    {
     2875      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     2876      return PclZip::errorCode();
     2877    }
     2878
     2879    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     2880    fseek($v_file_compressed, 10);
     2881    $v_size = $p_header['compressed_size'];
     2882    while ($v_size != 0)
     2883    {
     2884      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     2885      $v_buffer = @fread($v_file_compressed, $v_read_size);
     2886      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     2887      @fwrite($this->zip_fd, $v_buffer, $v_read_size);
     2888      $v_size -= $v_read_size;
     2889    }
     2890
     2891    // ----- Close the file
     2892    @fclose($v_file_compressed);
     2893
     2894    // ----- Unlink the temporary file
     2895    @unlink($v_gzip_temp_name);
     2896   
     2897    // ----- Return
    27172898    return $v_result;
    27182899  }
     
    27292910  function privCalculateStoredFilename(&$p_filedescr, &$p_options)
    27302911  {
    2731     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCalculateStoredFilename", "filename='".$p_filedescr['filename']."'");
    27322912    $v_result=1;
    27332913   
     
    27532933    }
    27542934
     2935
    27552936    // ----- Look for full name change
    27562937    if (isset($p_filedescr['new_full_name'])) {
    2757       $v_stored_filename = $p_filedescr['new_full_name'];
    2758       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Changing full name of '".$p_filename."' for '".$v_stored_filename."'");
     2938      // ----- Remove drive letter if any
     2939      $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
    27592940    }
    27602941   
     
    27632944
    27642945      // ----- Look for short name change
     2946      // Its when we cahnge just the filename but not the path
    27652947      if (isset($p_filedescr['new_short_name'])) {
    27662948        $v_path_info = pathinfo($p_filename);
     
    27702952        }
    27712953        $v_stored_filename = $v_dir.$p_filedescr['new_short_name'];
    2772         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Changing short name of '".$p_filename."' for '".$v_stored_filename."'");
    27732954      }
    27742955      else {
     
    27802961      if ($p_remove_all_dir) {
    27812962        $v_stored_filename = basename($p_filename);
    2782         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Remove all path selected change '".$p_filename."' for '".$v_stored_filename."'");
    27832963      }
    27842964      // ----- Look for partial path remove
     
    28052985          if ($v_compare == 2) {
    28062986            $v_stored_filename = "";
    2807             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Path to remove is the current folder");
    28082987          }
    28092988          else {
    2810             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Remove path '$p_remove_dir' in file '$v_stored_filename'");
    28112989            $v_stored_filename = substr($v_stored_filename,
    28122990                                        strlen($p_remove_dir));
    2813             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Result is '$v_stored_filename'");
    2814           }
    2815         }
    2816       }
     2991          }
     2992        }
     2993      }
     2994     
     2995      // ----- Remove drive letter if any
     2996      $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
     2997     
    28172998      // ----- Look for path to add
    28182999      if ($p_add_dir != "") {
     
    28213002        else
    28223003          $v_stored_filename = $p_add_dir."/".$v_stored_filename;
    2823         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Add path '$p_add_dir' in file '$p_filename' = '$v_stored_filename'");
    28243004      }
    28253005    }
     
    28283008    $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
    28293009    $p_filedescr['stored_filename'] = $v_stored_filename;
    2830     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Stored filename will be '".$p_filedescr['stored_filename']."', strlen ".strlen($p_filedescr['stored_filename']));
    28313010   
    28323011    // ----- Return
    2833     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    28343012    return $v_result;
    28353013  }
     
    28443022  function privWriteFileHeader(&$p_header)
    28453023  {
    2846     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privWriteFileHeader", 'file="'.$p_header['filename'].'", stored as "'.$p_header['stored_filename'].'"');
    28473024    $v_result=1;
    28483025
    28493026    // ----- Store the offset position of the file
    28503027    $p_header['offset'] = ftell($this->zip_fd);
    2851     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'File offset of the header :'.$p_header['offset']);
    28523028
    28533029    // ----- Transform UNIX mtime to DOS format mdate/mtime
    2854     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Date : \''.date("d/m/y H:i:s", $p_header['mtime']).'\'');
    28553030    $v_date = getdate($p_header['mtime']);
    28563031    $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
     
    28803055
    28813056    // ----- Return
    2882     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    28833057    return $v_result;
    28843058  }
     
    28933067  function privWriteCentralFileHeader(&$p_header)
    28943068  {
    2895     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privWriteCentralFileHeader", 'file="'.$p_header['filename'].'", stored as "'.$p_header['stored_filename'].'"');
    28963069    $v_result=1;
    28973070
    28983071    // TBC
    28993072    //for(reset($p_header); $key = key($p_header); next($p_header)) {
    2900     //  //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "header[$key] = ".$p_header[$key]);
    29013073    //}
    29023074
    29033075    // ----- Transform UNIX mtime to DOS format mdate/mtime
    2904     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Date : \''.date("d/m/y H:i:s", $p_header['mtime']).'\'');
    29053076    $v_date = getdate($p_header['mtime']);
    29063077    $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
    29073078    $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
     3079
    29083080
    29093081    // ----- Packed data
     
    29363108
    29373109    // ----- Return
    2938     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    29393110    return $v_result;
    29403111  }
     
    29493120  function privWriteCentralHeader($p_nb_entries, $p_size, $p_offset, $p_comment)
    29503121  {
    2951     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privWriteCentralHeader", 'nb_entries='.$p_nb_entries.', size='.$p_size.', offset='.$p_offset.', comment="'.$p_comment.'"');
    29523122    $v_result=1;
    29533123
     
    29673137
    29683138    // ----- Return
    2969     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    29703139    return $v_result;
    29713140  }
     
    29803149  function privList(&$p_list)
    29813150  {
    2982     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privList", "list");
    29833151    $v_result=1;
    29843152
     
    29873155
    29883156    // ----- Open the zip file
    2989     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    29903157    if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
    29913158    {
     
    29973164
    29983165      // ----- Return
    2999       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    30003166      return PclZip::errorCode();
    30013167    }
     
    30063172    {
    30073173      $this->privSwapBackMagicQuotes();
    3008       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    30093174      return $v_result;
    30103175    }
    30113176
    30123177    // ----- Go to beginning of Central Dir
    3013     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Offset : ".$v_central_dir['offset']."'");
    3014     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Position in file : ".ftell($this->zip_fd)."'");
    30153178    @rewind($this->zip_fd);
    3016     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Position in file : ".ftell($this->zip_fd)."'");
    30173179    if (@fseek($this->zip_fd, $v_central_dir['offset']))
    30183180    {
     
    30233185
    30243186      // ----- Return
    3025       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    30263187      return PclZip::errorCode();
    30273188    }
    3028     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Position in file : ".ftell($this->zip_fd)."'");
    30293189
    30303190    // ----- Read each entry
     
    30353195      {
    30363196        $this->privSwapBackMagicQuotes();
    3037         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    30383197        return $v_result;
    30393198      }
     
    30523211
    30533212    // ----- Return
    3054     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    30553213    return $v_result;
    30563214  }
     
    30723230  //     $p_info['folder'] = true/false : indicates if the entry is a folder or not.
    30733231  //     $p_info['status'] = status of the action on the file.
     3232  //     $p_info['crc'] = CRC of the file content.
    30743233  // Parameters :
    30753234  // Return Values :
     
    30773236  function privConvertHeader2FileInfo($p_header, &$p_info)
    30783237  {
    3079     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privConvertHeader2FileInfo", "Filename='".$p_header['filename']."'");
    30803238    $v_result=1;
    30813239
    30823240    // ----- Get the interesting attributes
    3083     $p_info['filename'] = $p_header['filename'];
    3084     $p_info['stored_filename'] = $p_header['stored_filename'];
     3241    $v_temp_path = PclZipUtilPathReduction($p_header['filename']);
     3242    $p_info['filename'] = $v_temp_path;
     3243    $v_temp_path = PclZipUtilPathReduction($p_header['stored_filename']);
     3244    $p_info['stored_filename'] = $v_temp_path;
    30853245    $p_info['size'] = $p_header['size'];
    30863246    $p_info['compressed_size'] = $p_header['compressed_size'];
     
    30903250    $p_info['index'] = $p_header['index'];
    30913251    $p_info['status'] = $p_header['status'];
     3252    $p_info['crc'] = $p_header['crc'];
    30923253
    30933254    // ----- Return
    3094     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    30953255    return $v_result;
    30963256  }
     
    31153275  function privExtractByRule(&$p_file_list, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
    31163276  {
    3117     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privExtractByRule", "path='$p_path', remove_path='$p_remove_path', remove_all_path='".($p_remove_all_path?'true':'false')."'");
    31183277    $v_result=1;
    31193278
     
    31343293      while (substr($p_path, -1) == "/")
    31353294      {
    3136         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Destination path [$p_path] ends by '/'");
    31373295        $p_path = substr($p_path, 0, strlen($p_path)-1);
    3138         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Modified to [$p_path]");
    31393296      }
    31403297    }
     
    31483305
    31493306    // ----- Open the zip file
    3150     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    31513307    if (($v_result = $this->privOpenFd('rb')) != 1)
    31523308    {
    31533309      $this->privSwapBackMagicQuotes();
    3154       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    31553310      return $v_result;
    31563311    }
     
    31643319      $this->privSwapBackMagicQuotes();
    31653320
    3166       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    31673321      return $v_result;
    31683322    }
     
    31753329    for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
    31763330    {
    3177       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Read next file header entry : '$i'");
    31783331
    31793332      // ----- Read next Central dir entry
    3180       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Position before rewind : ".ftell($this->zip_fd)."'");
    31813333      @rewind($this->zip_fd);
    3182       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Position after rewind : ".ftell($this->zip_fd)."'");
    31833334      if (@fseek($this->zip_fd, $v_pos_entry))
    31843335      {
     
    31913342
    31923343        // ----- Return
    3193         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    31943344        return PclZip::errorCode();
    31953345      }
    3196       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Position after fseek : ".ftell($this->zip_fd)."'");
    31973346
    31983347      // ----- Read the file header
     
    32043353        $this->privSwapBackMagicQuotes();
    32053354
    3206         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    32073355        return $v_result;
    32083356      }
     
    32203368      if (   (isset($p_options[PCLZIP_OPT_BY_NAME]))
    32213369          && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
    3222           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract with rule 'ByName'");
    32233370
    32243371          // ----- Look if the filename is in the list
    32253372          for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_extract); $j++) {
    3226               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Compare with file '".$p_options[PCLZIP_OPT_BY_NAME][$j]."'");
    32273373
    32283374              // ----- Look for a directory
    32293375              if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
    3230                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The searched item is a directory");
    32313376
    32323377                  // ----- Look if the directory is in the filename path
    32333378                  if (   (strlen($v_header['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
    32343379                      && (substr($v_header['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
    3235                       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The directory is in the file path");
    32363380                      $v_extract = true;
    32373381                  }
     
    32393383              // ----- Look for a filename
    32403384              elseif ($v_header['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
    3241                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The file is the right one.");
    32423385                  $v_extract = true;
    32433386              }
     
    32463389
    32473390      // ----- Look for extract by ereg rule
     3391      // ereg() is deprecated with PHP 5.3
     3392      /*
    32483393      else if (   (isset($p_options[PCLZIP_OPT_BY_EREG]))
    32493394               && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
    3250           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract by ereg '".$p_options[PCLZIP_OPT_BY_EREG]."'");
    32513395
    32523396          if (ereg($p_options[PCLZIP_OPT_BY_EREG], $v_header['stored_filename'])) {
    3253               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filename match the regular expression");
    32543397              $v_extract = true;
    32553398          }
    32563399      }
     3400      */
    32573401
    32583402      // ----- Look for extract by preg rule
    32593403      else if (   (isset($p_options[PCLZIP_OPT_BY_PREG]))
    32603404               && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
    3261           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract with rule 'ByEreg'");
    32623405
    32633406          if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header['stored_filename'])) {
    3264               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filename match the regular expression");
    32653407              $v_extract = true;
    32663408          }
     
    32703412      else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX]))
    32713413               && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
    3272           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract with rule 'ByIndex'");
    32733414         
    32743415          // ----- Look if the index is in the list
    32753416          for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) {
    3276               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Look if index '$i' is in [".$p_options[PCLZIP_OPT_BY_INDEX][$j]['start'].",".$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']."]");
    32773417
    32783418              if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
    3279                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Found as part of an index range");
    32803419                  $v_extract = true;
    32813420              }
    32823421              if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
    3283                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Do not look this index range for next loop");
    32843422                  $j_start = $j+1;
    32853423              }
    32863424
    32873425              if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
    3288                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Index range is greater than index, stop loop");
    32893426                  break;
    32903427              }
     
    32943431      // ----- Look for no rule, which means extract all the archive
    32953432      else {
    3296           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract with no rule (extract all)");
    32973433          $v_extract = true;
    32983434      }
     
    33023438              && (   ($v_header['compression'] != 8)
    33033439                      && ($v_header['compression'] != 0))) {
    3304           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unsupported compression method (".$v_header['compression'].")");
    33053440          $v_header['status'] = 'unsupported_compression';
    33063441
     
    33083443          if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    33093444                      && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3310               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "PCLZIP_OPT_STOP_ON_ERROR is selected, extraction will be stopped");
    33113445
    33123446              $this->privSwapBackMagicQuotes();
     
    33173451                                                           ."method (".$v_header['compression'].") ");
    33183452
    3319               //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    33203453              return PclZip::errorCode();
    33213454                  }
     
    33243457          // ----- Check encrypted files
    33253458          if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
    3326           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unsupported file encryption");
    33273459          $v_header['status'] = 'unsupported_encryption';
    33283460
     
    33303462          if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    33313463                      && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3332               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "PCLZIP_OPT_STOP_ON_ERROR is selected, extraction will be stopped");
    33333464
    33343465              $this->privSwapBackMagicQuotes();
     
    33393470                                                                   ."'");
    33403471
    3341               //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    33423472              return PclZip::errorCode();
    33433473                  }
     
    33463476      // ----- Look for real extraction
    33473477      if (($v_extract) && ($v_header['status'] != 'ok')) {
    3348           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "No need for extract");
    33493478          $v_result = $this->privConvertHeader2FileInfo($v_header,
    33503479                                                        $p_file_list[$v_nb_extracted++]);
     
    33523481              $this->privCloseFd();
    33533482              $this->privSwapBackMagicQuotes();
    3354               //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    33553483              return $v_result;
    33563484          }
     
    33623490      if ($v_extract)
    33633491      {
    3364         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting file '".$v_header['filename']."', index '$i'");
    33653492
    33663493        // ----- Go to the file position
    3367         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position before rewind : ".ftell($this->zip_fd)."'");
    33683494        @rewind($this->zip_fd);
    3369         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position after rewind : ".ftell($this->zip_fd)."'");
    33703495        if (@fseek($this->zip_fd, $v_header['offset']))
    33713496        {
     
    33793504
    33803505          // ----- Return
    3381           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    33823506          return PclZip::errorCode();
    33833507        }
    3384         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position after fseek : ".ftell($this->zip_fd)."'");
    33853508
    33863509        // ----- Look for extraction as string
    33873510        if ($p_options[PCLZIP_OPT_EXTRACT_AS_STRING]) {
    33883511
     3512          $v_string = '';
     3513
    33893514          // ----- Extracting the file
    3390           $v_result1 = $this->privExtractFileAsString($v_header, $v_string);
     3515          $v_result1 = $this->privExtractFileAsString($v_header, $v_string, $p_options);
    33913516          if ($v_result1 < 1) {
    33923517            $this->privCloseFd();
    33933518            $this->privSwapBackMagicQuotes();
    3394             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result1);
    33953519            return $v_result1;
    33963520          }
     
    34033527            $this->privSwapBackMagicQuotes();
    34043528
    3405             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    34063529            return $v_result;
    34073530          }
     
    34263549            $this->privCloseFd();
    34273550            $this->privSwapBackMagicQuotes();
    3428             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result1);
    34293551            return $v_result1;
    34303552          }
     
    34343556            $this->privCloseFd();
    34353557            $this->privSwapBackMagicQuotes();
    3436             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    34373558            return $v_result;
    34383559          }
     
    34533574            $this->privCloseFd();
    34543575            $this->privSwapBackMagicQuotes();
    3455             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result1);
    34563576            return $v_result1;
    34573577          }
     
    34643584            $this->privSwapBackMagicQuotes();
    34653585
    3466             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    34673586            return $v_result;
    34683587          }
     
    34813600
    34823601    // ----- Return
    3483     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    34843602    return $v_result;
    34853603  }
     
    34973615  function privExtractFile(&$p_entry, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
    34983616  {
    3499     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privExtractFile', "path='$p_path', remove_path='$p_remove_path', remove_all_path='".($p_remove_all_path?'true':'false')."'");
    35003617    $v_result=1;
    35013618
     
    35043621    {
    35053622      // ----- Return
    3506       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    35073623      return $v_result;
    35083624    }
    35093625
    3510     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Found file '".$v_header['filename']."', size '".$v_header['size']."'");
    35113626
    35123627    // ----- Check that the file header is coherent with $p_entry info
     
    35193634        // ----- Look for folder entry that not need to be extracted
    35203635        if (($p_entry['external']&0x00000010)==0x00000010) {
    3521             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The entry is a folder : need to be filtered");
    35223636
    35233637            $p_entry['status'] = "filtered";
    35243638
    3525             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    35263639            return $v_result;
    35273640        }
    35283641
    3529         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "All path is removed");
    35303642        // ----- Get the basename of the path
    35313643        $p_entry['filename'] = basename($p_entry['filename']);
     
    35353647    else if ($p_remove_path != "")
    35363648    {
    3537       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Look for some path to remove");
    35383649      if (PclZipUtilPathInclusion($p_remove_path, $p_entry['filename']) == 2)
    35393650      {
    3540         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The folder is the same as the removed path '".$p_entry['filename']."'");
    35413651
    35423652        // ----- Change the file status
     
    35443654
    35453655        // ----- Return
    3546         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    35473656        return $v_result;
    35483657      }
     
    35513660      if (substr($p_entry['filename'], 0, $p_remove_path_size) == $p_remove_path)
    35523661      {
    3553         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Found path '$p_remove_path' to remove in file '".$p_entry['filename']."'");
    35543662
    35553663        // ----- Remove the path
    35563664        $p_entry['filename'] = substr($p_entry['filename'], $p_remove_path_size);
    35573665
    3558         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Resulting file is '".$p_entry['filename']."'");
    35593666      }
    35603667    }
     
    35673674    // ----- Check a base_dir_restriction
    35683675    if (isset($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION])) {
    3569       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Check the extract directory restriction");
    35703676      $v_inclusion
    35713677      = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION],
    35723678                                $p_entry['filename']);
    35733679      if ($v_inclusion == 0) {
    3574         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "PCLZIP_OPT_EXTRACT_DIR_RESTRICTION is selected, file is outside restriction");
    35753680
    35763681        PclZip::privErrorLog(PCLZIP_ERR_DIRECTORY_RESTRICTION,
     
    35783683                                                                 ."outside PCLZIP_OPT_EXTRACT_DIR_RESTRICTION");
    35793684
    3580         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    35813685        return PclZip::errorCode();
    35823686      }
     
    35853689    // ----- Look for pre-extract callback
    35863690    if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
    3587       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A pre-callback '".$p_options[PCLZIP_CB_PRE_EXTRACT]."()') is defined for the extraction");
    35883691
    35893692      // ----- Generate a local information
     
    35943697      // Here I do not use call_user_func() because I need to send a reference to the
    35953698      // header.
    3596       eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
     3699//      eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
     3700      $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
    35973701      if ($v_result == 0) {
    35983702        // ----- Change the file status
     
    36033707      // ----- Look for abort result
    36043708      if ($v_result == 2) {
    3605         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "User callback abort the extraction");
    36063709        // ----- This status is internal and will be changed in 'skipped'
    36073710        $p_entry['status'] = "aborted";
     
    36123715      // Only some fields can be modified
    36133716      $p_entry['filename'] = $v_local_header['filename'];
    3614       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "New filename is '".$p_entry['filename']."'");
    3615     }
    3616 
    3617     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting file (with path) '".$p_entry['filename']."', size '$v_header[size]'");
     3717    }
     3718
    36183719
    36193720    // ----- Look if extraction should be done
     
    36233724    if (file_exists($p_entry['filename']))
    36243725    {
    3625       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$p_entry['filename']."' already exists");
    36263726
    36273727      // ----- Look if file is a directory
    36283728      if (is_dir($p_entry['filename']))
    36293729      {
    3630         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Existing file '".$p_entry['filename']."' is a directory");
    36313730
    36323731        // ----- Change the file status
     
    36383737        if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    36393738                    && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3640             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "PCLZIP_OPT_STOP_ON_ERROR is selected, extraction will be stopped");
    36413739
    36423740            PclZip::privErrorLog(PCLZIP_ERR_ALREADY_A_DIRECTORY,
     
    36443742                                                                 ."already used by an existing directory");
    36453743
    3646             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    36473744            return PclZip::errorCode();
    3648                 }
     3745                    }
    36493746      }
    36503747      // ----- Look if file is write protected
    36513748      else if (!is_writeable($p_entry['filename']))
    36523749      {
    3653         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Existing file '".$p_entry['filename']."' is write protected");
    36543750
    36553751        // ----- Change the file status
     
    36613757        if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    36623758                    && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3663             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "PCLZIP_OPT_STOP_ON_ERROR is selected, extraction will be stopped");
    36643759
    36653760            PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
     
    36673762                                                                 ."and is write protected");
    36683763
    3669             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    36703764            return PclZip::errorCode();
    3671                 }
     3765                    }
    36723766      }
    36733767
     
    36753769      else if (filemtime($p_entry['filename']) > $p_entry['mtime'])
    36763770      {
    3677         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Existing file '".$p_entry['filename']."' is newer (".date("l dS of F Y h:i:s A", filemtime($p_entry['filename'])).") than the extracted file (".date("l dS of F Y h:i:s A", $p_entry['mtime']).")");
    36783771        // ----- Change the file status
    36793772        if (   (isset($p_options[PCLZIP_OPT_REPLACE_NEWER]))
    36803773                    && ($p_options[PCLZIP_OPT_REPLACE_NEWER]===true)) {
    3681             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "PCLZIP_OPT_REPLACE_NEWER is selected, file will be replaced");
    3682                 }
    3683                 else {
    3684             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File will not be replaced");
     3774                  }
     3775                    else {
    36853776            $p_entry['status'] = "newer_exist";
    36863777
     
    36903781            if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
    36913782                        && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
    3692                 //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "PCLZIP_OPT_STOP_ON_ERROR is selected, extraction will be stopped");
    36933783
    36943784                PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
     
    36963786                                            ."and option PCLZIP_OPT_REPLACE_NEWER is not selected");
    36973787
    3698                 //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    36993788                return PclZip::errorCode();
     3789                      }
    37003790                    }
    3701                 }
    37023791      }
    37033792      else {
    3704         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Existing file '".$p_entry['filename']."' is older than the extrated one - will be replaced by the extracted one (".date("l dS of F Y h:i:s A", filemtime($p_entry['filename'])).") than the extracted file (".date("l dS of F Y h:i:s A", $p_entry['mtime']).")");
    37053793      }
    37063794    }
     
    37153803        $v_dir_to_check = dirname($p_entry['filename']);
    37163804
    3717       if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) {
    3718         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to create path for '".$p_entry['filename']."'");
    3719 
    3720         // ----- Change the file status
    3721         $p_entry['status'] = "path_creation_fail";
    3722 
    3723         // ----- Return
    3724         ////--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    3725         //return $v_result;
    3726         $v_result = 1;
    3727       }
    3728     }
     3805        if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) {
     3806 
     3807          // ----- Change the file status
     3808          $p_entry['status'] = "path_creation_fail";
     3809 
     3810          // ----- Return
     3811          //return $v_result;
     3812          $v_result = 1;
     3813        }
     3814      }
    37293815    }
    37303816
    37313817    // ----- Look if extraction should be done
    37323818    if ($p_entry['status'] == 'ok') {
    3733 
    3734         // ----- Look for chmod option
    3735         if (is_dir($p_entry['filename']) AND isset($p_options[PCLZIP_OPT_SET_CHMOD])) {
    3736           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "chmod option activated '".$p_options[PCLZIP_OPT_SET_CHMOD]."'");
    3737 
    3738           // ----- Change the mode of the file
    3739           @chmod($p_entry['filename'], $p_options[PCLZIP_OPT_SET_CHMOD]);
    3740         }
    37413819
    37423820      // ----- Do the extraction (if not a folder)
     
    37453823        // ----- Look for not compressed file
    37463824        if ($p_entry['compression'] == 0) {
    3747           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting an un-compressed file");
    3748 
    3749                   // ----- Opening destination file
     3825
     3826                  // ----- Opening destination file
    37503827          if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0)
    37513828          {
    3752             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Error while opening '".$p_entry['filename']."' in write binary mode");
    37533829
    37543830            // ----- Change the file status
     
    37563832
    37573833            // ----- Return
    3758             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    37593834            return $v_result;
    37603835          }
    37613836
    3762           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read '".$p_entry['size']."' bytes");
    37633837
    37643838          // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     
    37673841          {
    37683842            $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    3769             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read $v_read_size bytes");
    37703843            $v_buffer = @fread($this->zip_fd, $v_read_size);
    37713844            /* Try to speed up the code
     
    37863859        }
    37873860        else {
    3788           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting a compressed file (Compression method ".$p_entry['compression'].")");
    37893861          // ----- TBC
    37903862          // Need to be finished
    37913863          if (($p_entry['flag'] & 1) == 1) {
    3792               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File is encrypted");
    3793             /*
    3794               // ----- Read the encryption header
    3795               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read 12 encryption header bytes");
    3796               $v_encryption_header = @fread($this->zip_fd, 12);
     3864            PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION, 'File \''.$p_entry['filename'].'\' is encrypted. Encrypted files are not supported.');
     3865            return PclZip::errorCode();
     3866          }
     3867
     3868
     3869          // ----- Look for using temporary file to unzip
     3870          if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
     3871              && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
     3872                  || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     3873                      && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_entry['size'])) ) ) {
     3874            $v_result = $this->privExtractFileUsingTempFile($p_entry, $p_options);
     3875            if ($v_result < PCLZIP_ERR_NO_ERROR) {
     3876              return $v_result;
     3877            }
     3878          }
     3879         
     3880          // ----- Look for extract in memory
     3881          else {
     3882
     3883         
     3884            // ----- Read the compressed file in a buffer (one shot)
     3885            $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
     3886           
     3887            // ----- Decompress the file
     3888            $v_file_content = @gzinflate($v_buffer);
     3889            unset($v_buffer);
     3890            if ($v_file_content === FALSE) {
     3891 
     3892              // ----- Change the file status
     3893              // TBC
     3894              $p_entry['status'] = "error";
    37973895             
    3798               // ----- Read the encrypted & compressed file in a buffer
    3799               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read '".($p_entry['compressed_size']-12)."' compressed & encrypted bytes");
    3800               $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']-12);
    3801              
    3802               // ----- Decrypt the buffer
    3803               $this->privDecrypt($v_encryption_header, $v_buffer,
    3804                                              $p_entry['compressed_size']-12, $p_entry['crc']);
    3805               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Buffer is '".$v_buffer."'");
    3806               */
    3807           }
    3808           else {
    3809               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read '".$p_entry['compressed_size']."' compressed bytes");
    3810               // ----- Read the compressed file in a buffer (one shot)
    3811               $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
    3812           }
    3813          
    3814           // ----- Decompress the file
    3815           $v_file_content = @gzinflate($v_buffer);
    3816           unset($v_buffer);
    3817           if ($v_file_content === FALSE) {
    3818             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to inflate compressed file");
    3819 
    3820             // ----- Change the file status
    3821             // TBC
    3822             $p_entry['status'] = "error";
     3896              return $v_result;
     3897            }
    38233898           
    3824             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    3825             return $v_result;
    3826           }
    3827          
    3828           // ----- Opening destination file
    3829           if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
    3830             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Error while opening '".$p_entry['filename']."' in write binary mode");
    3831 
    3832             // ----- Change the file status
    3833             $p_entry['status'] = "write_error";
    3834 
    3835             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    3836             return $v_result;
    3837           }
    3838 
    3839           // ----- Write the uncompressed data
    3840           @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
    3841           unset($v_file_content);
    3842 
    3843           // ----- Closing the destination file
    3844           @fclose($v_dest_file);
     3899            // ----- Opening destination file
     3900            if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
     3901 
     3902              // ----- Change the file status
     3903              $p_entry['status'] = "write_error";
     3904 
     3905              return $v_result;
     3906            }
     3907 
     3908            // ----- Write the uncompressed data
     3909            @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
     3910            unset($v_file_content);
     3911 
     3912            // ----- Closing the destination file
     3913            @fclose($v_dest_file);
     3914           
     3915          }
    38453916
    38463917          // ----- Change the file mtime
     
    38503921        // ----- Look for chmod option
    38513922        if (isset($p_options[PCLZIP_OPT_SET_CHMOD])) {
    3852           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "chmod option activated '".$p_options[PCLZIP_OPT_SET_CHMOD]."'");
    38533923
    38543924          // ----- Change the mode of the file
    3855           @chmod($p_entry['filename'], $p_options[PCLZIP_OPT_SET_CHMOD] & ~0111);
    3856         }
    3857 
    3858         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extraction done");
    3859       }
    3860     }
    3861 
    3862         // ----- Change abort status
    3863         if ($p_entry['status'] == "aborted") {
    3864       $p_entry['status'] = "skipped";
    3865         }
     3925          @chmod($p_entry['filename'], $p_options[PCLZIP_OPT_SET_CHMOD]);
     3926        }
     3927
     3928      }
     3929    }
     3930
     3931        // ----- Change abort status
     3932        if ($p_entry['status'] == "aborted") {
     3933        $p_entry['status'] = "skipped";
     3934        }
    38663935       
    38673936    // ----- Look for post-extract callback
    38683937    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
    3869       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A post-callback '".$p_options[PCLZIP_CB_POST_EXTRACT]."()') is defined for the extraction");
    38703938
    38713939      // ----- Generate a local information
     
    38763944      // Here I do not use call_user_func() because I need to send a reference to the
    38773945      // header.
    3878       eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
     3946//      eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
     3947      $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
    38793948
    38803949      // ----- Look for abort result
    38813950      if ($v_result == 2) {
    3882         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "User callback abort the extraction");
    38833951        $v_result = PCLZIP_ERR_USER_ABORTED;
    38843952      }
     
    38863954
    38873955    // ----- Return
    3888     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     3956    return $v_result;
     3957  }
     3958  // --------------------------------------------------------------------------------
     3959
     3960  // --------------------------------------------------------------------------------
     3961  // Function : privExtractFileUsingTempFile()
     3962  // Description :
     3963  // Parameters :
     3964  // Return Values :
     3965  // --------------------------------------------------------------------------------
     3966  function privExtractFileUsingTempFile(&$p_entry, &$p_options)
     3967  {
     3968    $v_result=1;
     3969       
     3970    // ----- Creates a temporary file
     3971    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
     3972    if (($v_dest_file = @fopen($v_gzip_temp_name, "wb")) == 0) {
     3973      fclose($v_file);
     3974      PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
     3975      return PclZip::errorCode();
     3976    }
     3977
     3978
     3979    // ----- Write gz file format header
     3980    $v_binary_data = pack('va1a1Va1a1', 0x8b1f, Chr($p_entry['compression']), Chr(0x00), time(), Chr(0x00), Chr(3));
     3981    @fwrite($v_dest_file, $v_binary_data, 10);
     3982
     3983    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     3984    $v_size = $p_entry['compressed_size'];
     3985    while ($v_size != 0)
     3986    {
     3987      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     3988      $v_buffer = @fread($this->zip_fd, $v_read_size);
     3989      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     3990      @fwrite($v_dest_file, $v_buffer, $v_read_size);
     3991      $v_size -= $v_read_size;
     3992    }
     3993
     3994    // ----- Write gz file format footer
     3995    $v_binary_data = pack('VV', $p_entry['crc'], $p_entry['size']);
     3996    @fwrite($v_dest_file, $v_binary_data, 8);
     3997
     3998    // ----- Close the temporary file
     3999    @fclose($v_dest_file);
     4000
     4001    // ----- Opening destination file
     4002    if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
     4003      $p_entry['status'] = "write_error";
     4004      return $v_result;
     4005    }
     4006
     4007    // ----- Open the temporary gz file
     4008    if (($v_src_file = @gzopen($v_gzip_temp_name, 'rb')) == 0) {
     4009      @fclose($v_dest_file);
     4010      $p_entry['status'] = "read_error";
     4011      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     4012      return PclZip::errorCode();
     4013    }
     4014
     4015
     4016    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     4017    $v_size = $p_entry['size'];
     4018    while ($v_size != 0) {
     4019      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     4020      $v_buffer = @gzread($v_src_file, $v_read_size);
     4021      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     4022      @fwrite($v_dest_file, $v_buffer, $v_read_size);
     4023      $v_size -= $v_read_size;
     4024    }
     4025    @fclose($v_dest_file);
     4026    @gzclose($v_src_file);
     4027
     4028    // ----- Delete the temporary file
     4029    @unlink($v_gzip_temp_name);
     4030   
     4031    // ----- Return
    38894032    return $v_result;
    38904033  }
     
    38994042  function privExtractFileInOutput(&$p_entry, &$p_options)
    39004043  {
    3901     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privExtractFileInOutput', "");
    39024044    $v_result=1;
    39034045
    39044046    // ----- Read the file header
    39054047    if (($v_result = $this->privReadFileHeader($v_header)) != 1) {
    3906       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    39074048      return $v_result;
    39084049    }
    39094050
    3910     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Found file '".$v_header['filename']."', size '".$v_header['size']."'");
    39114051
    39124052    // ----- Check that the file header is coherent with $p_entry info
     
    39174057    // ----- Look for pre-extract callback
    39184058    if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
    3919       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A pre-callback '".$p_options[PCLZIP_CB_PRE_EXTRACT]."()') is defined for the extraction");
    39204059
    39214060      // ----- Generate a local information
     
    39264065      // Here I do not use call_user_func() because I need to send a reference to the
    39274066      // header.
    3928       eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
     4067//      eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
     4068      $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
    39294069      if ($v_result == 0) {
    39304070        // ----- Change the file status
     
    39354075      // ----- Look for abort result
    39364076      if ($v_result == 2) {
    3937         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "User callback abort the extraction");
    39384077        // ----- This status is internal and will be changed in 'skipped'
    39394078        $p_entry['status'] = "aborted";
     
    39444083      // Only some fields can be modified
    39454084      $p_entry['filename'] = $v_local_header['filename'];
    3946       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "New filename is '".$p_entry['filename']."'");
    39474085    }
    39484086
    39494087    // ----- Trace
    3950     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting file (with path) '".$p_entry['filename']."', size '$v_header[size]'");
    39514088
    39524089    // ----- Look if extraction should be done
     
    39574094        // ----- Look for not compressed file
    39584095        if ($p_entry['compressed_size'] == $p_entry['size']) {
    3959           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting an un-compressed file");
    3960           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Reading '".$p_entry['size']."' bytes");
    39614096
    39624097          // ----- Read the file in a buffer (one shot)
     
    39684103        }
    39694104        else {
    3970           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting a compressed file");
    3971           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Reading '".$p_entry['size']."' bytes");
    39724105
    39734106          // ----- Read the compressed file in a buffer (one shot)
     
    39824115          unset($v_file_content);
    39834116        }
    3984         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extraction done");
    39854117      }
    39864118    }
     
    39934125    // ----- Look for post-extract callback
    39944126    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
    3995       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "A post-callback '".$p_options[PCLZIP_CB_POST_EXTRACT]."()') is defined for the extraction");
    39964127
    39974128      // ----- Generate a local information
     
    40024133      // Here I do not use call_user_func() because I need to send a reference to the
    40034134      // header.
    4004       eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
     4135//      eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
     4136      $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
    40054137
    40064138      // ----- Look for abort result
    40074139      if ($v_result == 2) {
    4008         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "User callback abort the extraction");
    40094140        $v_result = PCLZIP_ERR_USER_ABORTED;
    40104141      }
    40114142    }
    40124143
    4013     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    40144144    return $v_result;
    40154145  }
     
    40224152  // Return Values :
    40234153  // --------------------------------------------------------------------------------
    4024   function privExtractFileAsString(&$p_entry, &$p_string)
     4154  function privExtractFileAsString(&$p_entry, &$p_string, &$p_options)
    40254155  {
    4026     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privExtractFileAsString', "p_entry['filename']='".$p_entry['filename']."'");
    40274156    $v_result=1;
    40284157
     
    40324161    {
    40334162      // ----- Return
    4034       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    40354163      return $v_result;
    40364164    }
    40374165
    4038     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Found file '".$v_header['filename']."', size '".$v_header['size']."'");
    40394166
    40404167    // ----- Check that the file header is coherent with $p_entry info
     
    40434170    }
    40444171
    4045     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting file in string (with path) '".$p_entry['filename']."', size '$v_header[size]'");
    4046 
    4047     // ----- Do the extraction (if not a folder)
    4048     if (!(($p_entry['external']&0x00000010)==0x00000010))
    4049     {
    4050       // ----- Look for not compressed file
    4051 //      if ($p_entry['compressed_size'] == $p_entry['size'])
    4052       if ($p_entry['compression'] == 0) {
    4053         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting an un-compressed file");
    4054         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Reading '".$p_entry['size']."' bytes");
    4055 
    4056         // ----- Reading the file
    4057         $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
     4172    // ----- Look for pre-extract callback
     4173    if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
     4174
     4175      // ----- Generate a local information
     4176      $v_local_header = array();
     4177      $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
     4178
     4179      // ----- Call the callback
     4180      // Here I do not use call_user_func() because I need to send a reference to the
     4181      // header.
     4182//      eval('$v_result = '.$p_options[PCLZIP_CB_PRE_EXTRACT].'(PCLZIP_CB_PRE_EXTRACT, $v_local_header);');
     4183      $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
     4184      if ($v_result == 0) {
     4185        // ----- Change the file status
     4186        $p_entry['status'] = "skipped";
     4187        $v_result = 1;
     4188      }
     4189     
     4190      // ----- Look for abort result
     4191      if ($v_result == 2) {
     4192        // ----- This status is internal and will be changed in 'skipped'
     4193        $p_entry['status'] = "aborted";
     4194        $v_result = PCLZIP_ERR_USER_ABORTED;
     4195      }
     4196
     4197      // ----- Update the informations
     4198      // Only some fields can be modified
     4199      $p_entry['filename'] = $v_local_header['filename'];
     4200    }
     4201
     4202
     4203    // ----- Look if extraction should be done
     4204    if ($p_entry['status'] == 'ok') {
     4205
     4206      // ----- Do the extraction (if not a folder)
     4207      if (!(($p_entry['external']&0x00000010)==0x00000010)) {
     4208        // ----- Look for not compressed file
     4209  //      if ($p_entry['compressed_size'] == $p_entry['size'])
     4210        if ($p_entry['compression'] == 0) {
     4211 
     4212          // ----- Reading the file
     4213          $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
     4214        }
     4215        else {
     4216 
     4217          // ----- Reading the file
     4218          $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
     4219         
     4220          // ----- Decompress the file
     4221          if (($p_string = @gzinflate($v_data)) === FALSE) {
     4222              // TBC
     4223          }
     4224        }
     4225 
     4226        // ----- Trace
    40584227      }
    40594228      else {
    4060         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting a compressed file (compression method '".$p_entry['compression']."')");
    4061 
    4062         // ----- Reading the file
    4063         $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
    4064        
    4065         // ----- Decompress the file
    4066         if (($p_string = @gzinflate($v_data)) === FALSE) {
    4067             // TBC
    4068         }
    4069       }
    4070 
    4071       // ----- Trace
    4072       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extraction done");
    4073     }
    4074     else {
    4075         // TBC : error : can not extract a folder in a string
     4229          // TBC : error : can not extract a folder in a string
     4230      }
     4231     
     4232    }
     4233
     4234        // ----- Change abort status
     4235        if ($p_entry['status'] == "aborted") {
     4236        $p_entry['status'] = "skipped";
     4237        }
     4238       
     4239    // ----- Look for post-extract callback
     4240    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
     4241
     4242      // ----- Generate a local information
     4243      $v_local_header = array();
     4244      $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
     4245     
     4246      // ----- Swap the content to header
     4247      $v_local_header['content'] = $p_string;
     4248      $p_string = '';
     4249
     4250      // ----- Call the callback
     4251      // Here I do not use call_user_func() because I need to send a reference to the
     4252      // header.
     4253//      eval('$v_result = '.$p_options[PCLZIP_CB_POST_EXTRACT].'(PCLZIP_CB_POST_EXTRACT, $v_local_header);');
     4254      $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
     4255
     4256      // ----- Swap back the content to header
     4257      $p_string = $v_local_header['content'];
     4258      unset($v_local_header['content']);
     4259
     4260      // ----- Look for abort result
     4261      if ($v_result == 2) {
     4262        $v_result = PCLZIP_ERR_USER_ABORTED;
     4263      }
    40764264    }
    40774265
    40784266    // ----- Return
    4079     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    40804267    return $v_result;
    40814268  }
     
    40904277  function privReadFileHeader(&$p_header)
    40914278  {
    4092     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privReadFileHeader", "");
    40934279    $v_result=1;
    40944280
    40954281    // ----- Read the 4 bytes signature
    40964282    $v_binary_data = @fread($this->zip_fd, 4);
    4097     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Binary data is : '".sprintf("%08x", $v_binary_data)."'");
    40984283    $v_data = unpack('Vid', $v_binary_data);
    4099     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Binary signature is : '".sprintf("0x%08x", $v_data['id'])."'");
    41004284
    41014285    // ----- Check signature
    41024286    if ($v_data['id'] != 0x04034b50)
    41034287    {
    4104       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Invalid File header");
    41054288
    41064289      // ----- Error log
     
    41084291
    41094292      // ----- Return
    4110       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    41114293      return PclZip::errorCode();
    41124294    }
     
    41204302      $p_header['filename'] = "";
    41214303      $p_header['status'] = "invalid_header";
    4122       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Invalid block size : ".strlen($v_binary_data));
    41234304
    41244305      // ----- Error log
     
    41264307
    41274308      // ----- Return
    4128       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    41294309      return PclZip::errorCode();
    41304310    }
    41314311
    41324312    // ----- Extract the values
    4133     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Header : '".$v_binary_data."'");
    4134     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Header (Hex) : '".bin2hex($v_binary_data)."'");
    41354313    $v_data = unpack('vversion/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len', $v_binary_data);
    41364314
    41374315    // ----- Get filename
    4138     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "File name length : ".$v_data['filename_len']);
    41394316    $p_header['filename'] = fread($this->zip_fd, $v_data['filename_len']);
    4140     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Filename : \''.$p_header['filename'].'\'');
    41414317
    41424318    // ----- Get extra_fields
    4143     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extra field length : ".$v_data['extra_len']);
    41444319    if ($v_data['extra_len'] != 0) {
    41454320      $p_header['extra'] = fread($this->zip_fd, $v_data['extra_len']);
     
    41484323      $p_header['extra'] = '';
    41494324    }
    4150     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Extra field : \''.bin2hex($p_header['extra']).'\'');
    41514325
    41524326    // ----- Extract properties
    41534327    $p_header['version_extracted'] = $v_data['version'];
    4154     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Version need to extract : ('.$p_header['version_extracted'].') \''.($p_header['version_extracted']/10).'.'.($p_header['version_extracted']%10).'\'');
    41554328    $p_header['compression'] = $v_data['compression'];
    4156     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Compression method : \''.$p_header['compression'].'\'');
    41574329    $p_header['size'] = $v_data['size'];
    4158     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Size : \''.$p_header['size'].'\'');
    41594330    $p_header['compressed_size'] = $v_data['compressed_size'];
    4160     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Compressed Size : \''.$p_header['compressed_size'].'\'');
    41614331    $p_header['crc'] = $v_data['crc'];
    4162     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'CRC : \''.sprintf("0x%X", $p_header['crc']).'\'');
    41634332    $p_header['flag'] = $v_data['flag'];
    4164     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Flag : \''.$p_header['flag'].'\'');
    41654333    $p_header['filename_len'] = $v_data['filename_len'];
    4166     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Filename_len : \''.$p_header['filename_len'].'\'');
    41674334
    41684335    // ----- Recuperate date in UNIX format
     
    41824349
    41834350      // ----- Get UNIX date format
    4184       $p_header['mtime'] = mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
    4185 
    4186       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Date : \''.date("d/m/y H:i:s", $p_header['mtime']).'\'');
     4351      $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
     4352
    41874353    }
    41884354    else
    41894355    {
    41904356      $p_header['mtime'] = time();
    4191       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Date is actual : \''.date("d/m/y H:i:s", $p_header['mtime']).'\'');
    41924357    }
    41934358
    41944359    // TBC
    41954360    //for(reset($v_data); $key = key($v_data); next($v_data)) {
    4196     //  //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Attribut[$key] = ".$v_data[$key]);
    41974361    //}
    41984362
     
    42044368
    42054369    // ----- Return
    4206     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    42074370    return $v_result;
    42084371  }
     
    42174380  function privReadCentralFileHeader(&$p_header)
    42184381  {
    4219     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privReadCentralFileHeader", "");
    42204382    $v_result=1;
    42214383
    42224384    // ----- Read the 4 bytes signature
    42234385    $v_binary_data = @fread($this->zip_fd, 4);
    4224     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Binary data is : '".sprintf("%08x", $v_binary_data)."'");
    42254386    $v_data = unpack('Vid', $v_binary_data);
    4226     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Binary signature is : '".sprintf("0x%08x", $v_data['id'])."'");
    42274387
    42284388    // ----- Check signature
    42294389    if ($v_data['id'] != 0x02014b50)
    42304390    {
    4231       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Invalid Central Dir File signature");
    42324391
    42334392      // ----- Error log
     
    42354394
    42364395      // ----- Return
    4237       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    42384396      return PclZip::errorCode();
    42394397    }
     
    42474405      $p_header['filename'] = "";
    42484406      $p_header['status'] = "invalid_header";
    4249       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Invalid block size : ".strlen($v_binary_data));
    42504407
    42514408      // ----- Error log
     
    42534410
    42544411      // ----- Return
    4255       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    42564412      return PclZip::errorCode();
    42574413    }
    42584414
    42594415    // ----- Extract the values
    4260     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Header : '".$v_binary_data."'");
    4261     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Header (Hex) : '".bin2hex($v_binary_data)."'");
    42624416    $p_header = unpack('vversion/vversion_extracted/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len/vcomment_len/vdisk/vinternal/Vexternal/Voffset', $v_binary_data);
    42634417
    42644418    // ----- Get filename
    4265     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "File name length : ".$p_header['filename_len']);
    42664419    if ($p_header['filename_len'] != 0)
    42674420      $p_header['filename'] = fread($this->zip_fd, $p_header['filename_len']);
    42684421    else
    42694422      $p_header['filename'] = '';
    4270     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Filename : \''.$p_header['filename'].'\'');
    42714423
    42724424    // ----- Get extra
    4273     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Extra length : ".$p_header['extra_len']);
    42744425    if ($p_header['extra_len'] != 0)
    42754426      $p_header['extra'] = fread($this->zip_fd, $p_header['extra_len']);
    42764427    else
    42774428      $p_header['extra'] = '';
    4278     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Extra : \''.$p_header['extra'].'\'');
    42794429
    42804430    // ----- Get comment
    4281     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Comment length : ".$p_header['comment_len']);
    42824431    if ($p_header['comment_len'] != 0)
    42834432      $p_header['comment'] = fread($this->zip_fd, $p_header['comment_len']);
    42844433    else
    42854434      $p_header['comment'] = '';
    4286     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Comment : \''.$p_header['comment'].'\'');
    42874435
    42884436    // ----- Extract properties
    4289     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Version : \''.($p_header['version']/10).'.'.($p_header['version']%10).'\'');
    4290     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Version need to extract : \''.($p_header['version_extracted']/10).'.'.($p_header['version_extracted']%10).'\'');
    4291     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Size : \''.$p_header['size'].'\'');
    4292     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Compressed Size : \''.$p_header['compressed_size'].'\'');
    4293     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'CRC : \''.sprintf("0x%X", $p_header['crc']).'\'');
    4294     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Flag : \''.$p_header['flag'].'\'');
    4295     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Offset : \''.$p_header['offset'].'\'');
    42964437
    42974438    // ----- Recuperate date in UNIX format
    4298     if ($p_header['mdate'] && $p_header['mtime'])
     4439    //if ($p_header['mdate'] && $p_header['mtime'])
     4440    // TBC : bug : this was ignoring time with 0/0/0
     4441    if (1)
    42994442    {
    43004443      // ----- Extract time
     
    43094452
    43104453      // ----- Get UNIX date format
    4311       $p_header['mtime'] = mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
    4312 
    4313       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Date : \''.date("d/m/y H:i:s", $p_header['mtime']).'\'');
     4454      $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
     4455
    43144456    }
    43154457    else
    43164458    {
    43174459      $p_header['mtime'] = time();
    4318       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Date is actual : \''.date("d/m/y H:i:s", $p_header['mtime']).'\'');
    43194460    }
    43204461
     
    43264467
    43274468    // ----- Look if it is a directory
    4328     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Internal (Hex) : '".sprintf("Ox%04X", $p_header['internal'])."'");
    4329     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "External (Hex) : '".sprintf("Ox%04X", $p_header['external'])."' (".(($p_header['external']&0x00000010)==0x00000010?'is a folder':'is a file').')');
    43304469    if (substr($p_header['filename'], -1) == '/') {
    43314470      //$p_header['external'] = 0x41FF0010;
    43324471      $p_header['external'] = 0x00000010;
    4333       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Force folder external : \''.sprintf("Ox%04X", $p_header['external']).'\'');
    4334     }
    4335 
    4336     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Header of filename : \''.$p_header['filename'].'\'');
     4472    }
     4473
    43374474
    43384475    // ----- Return
    4339     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    43404476    return $v_result;
    43414477  }
     
    43524488  function privCheckFileHeaders(&$p_local_header, &$p_central_header)
    43534489  {
    4354     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privCheckFileHeaders", "");
    43554490    $v_result=1;
    43564491
    4357         // ----- Check the static values
    4358         // TBC
    4359         if ($p_local_header['filename'] != $p_central_header['filename']) {
    4360         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "filename" : TBC To Be Completed');
    4361         }
    4362         if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
    4363         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "version_extracted" : TBC To Be Completed');
    4364         }
    4365         if ($p_local_header['flag'] != $p_central_header['flag']) {
    4366         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "flag" : TBC To Be Completed');
    4367         }
    4368         if ($p_local_header['compression'] != $p_central_header['compression']) {
    4369         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "compression" : TBC To Be Completed');
    4370         }
    4371         if ($p_local_header['mtime'] != $p_central_header['mtime']) {
    4372         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "mtime" : TBC To Be Completed');
    4373         }
    4374         if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
    4375         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "filename_len" : TBC To Be Completed');
    4376         }
    4377 
    4378         // ----- Look for flag bit 3
    4379         if (($p_local_header['flag'] & 8) == 8) {
    4380         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Purpose bit flag bit 3 set !');
    4381         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'File size, compression size and crc found in central header');
    4382         $p_local_header['size'] = $p_central_header['size'];
    4383         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Size : \''.$p_local_header['size'].'\'');
    4384         $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
    4385         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Compressed Size : \''.$p_local_header['compressed_size'].'\'');
    4386         $p_local_header['crc'] = $p_central_header['crc'];
    4387         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'CRC : \''.sprintf("0x%X", $p_local_header['crc']).'\'');
    4388         }
     4492        // ----- Check the static values
     4493        // TBC
     4494        if ($p_local_header['filename'] != $p_central_header['filename']) {
     4495        }
     4496        if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
     4497        }
     4498        if ($p_local_header['flag'] != $p_central_header['flag']) {
     4499        }
     4500        if ($p_local_header['compression'] != $p_central_header['compression']) {
     4501        }
     4502        if ($p_local_header['mtime'] != $p_central_header['mtime']) {
     4503        }
     4504        if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
     4505        }
     4506 
     4507        // ----- Look for flag bit 3
     4508        if (($p_local_header['flag'] & 8) == 8) {
     4509          $p_local_header['size'] = $p_central_header['size'];
     4510          $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
     4511          $p_local_header['crc'] = $p_central_header['crc'];
     4512        }
    43894513
    43904514    // ----- Return
    4391     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    43924515    return $v_result;
    43934516  }
     
    44024525  function privReadEndCentralDir(&$p_central_dir)
    44034526  {
    4404     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privReadEndCentralDir", "");
    44054527    $v_result=1;
    44064528
    44074529    // ----- Go to the end of the zip file
    44084530    $v_size = filesize($this->zipname);
    4409     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size of the file :$v_size");
    44104531    @fseek($this->zip_fd, $v_size);
    4411     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Position at end of zip file : \''.ftell($this->zip_fd).'\'');
    44124532    if (@ftell($this->zip_fd) != $v_size)
    44134533    {
     
    44164536
    44174537      // ----- Return
    4418       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    44194538      return PclZip::errorCode();
    44204539    }
     
    44244543    $v_found = 0;
    44254544    if ($v_size > 26) {
    4426       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Look for central dir with no comment');
    44274545      @fseek($this->zip_fd, $v_size-22);
    4428       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Position after min central position : \''.ftell($this->zip_fd).'\'');
    44294546      if (($v_pos = @ftell($this->zip_fd)) != ($v_size-22))
    44304547      {
     
    44334550
    44344551        // ----- Return
    4435         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    44364552        return PclZip::errorCode();
    44374553      }
     
    44394555      // ----- Read for bytes
    44404556      $v_binary_data = @fread($this->zip_fd, 4);
    4441       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Binary data is : '".sprintf("%08x", $v_binary_data)."'");
    44424557      $v_data = @unpack('Vid', $v_binary_data);
    4443       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Binary signature is : '".sprintf("0x%08x", $v_data['id'])."'");
    44444558
    44454559      // ----- Check signature
    44464560      if ($v_data['id'] == 0x06054b50) {
    4447         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Found central dir at the default position.");
    44484561        $v_found = 1;
    44494562      }
     
    44544567    // ----- Go back to the maximum possible size of the Central Dir End Record
    44554568    if (!$v_found) {
    4456       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Start extended search of end central dir');
    44574569      $v_maximum_size = 65557; // 0xFFFF + 22;
    44584570      if ($v_maximum_size > $v_size)
     
    44654577
    44664578        // ----- Return
    4467         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    44684579        return PclZip::errorCode();
    44694580      }
    4470       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Position after max central position : \''.ftell($this->zip_fd).'\'');
    44714581
    44724582      // ----- Read byte per byte in order to find the signature
     
    44794589
    44804590        // -----  Add the byte
    4481         $v_bytes = ($v_bytes << 8) | Ord($v_byte);
     4591        //$v_bytes = ($v_bytes << 8) | Ord($v_byte);
     4592        // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number
     4593        // Otherwise on systems where we have 64bit integers the check below for the magic number will fail.
     4594        $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte);
    44824595
    44834596        // ----- Compare the bytes
    44844597        if ($v_bytes == 0x504b0506)
    44854598        {
    4486           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, 'Found End Central Dir signature at position : \''.ftell($this->zip_fd).'\'');
    44874599          $v_pos++;
    44884600          break;
     
    44954607      if ($v_pos == $v_size)
    44964608      {
    4497         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to find End of Central Dir Record signature");
    44984609
    44994610        // ----- Error log
     
    45014612
    45024613        // ----- Return
    4503         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    45044614        return PclZip::errorCode();
    45054615      }
     
    45124622    if (strlen($v_binary_data) != 18)
    45134623    {
    4514       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Invalid End of Central Dir Record size : ".strlen($v_binary_data));
    45154624
    45164625      // ----- Error log
     
    45184627
    45194628      // ----- Return
    4520       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    45214629      return PclZip::errorCode();
    45224630    }
    45234631
    45244632    // ----- Extract the values
    4525     ////--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Central Dir Record : '".$v_binary_data."'");
    4526     ////--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Central Dir Record (Hex) : '".bin2hex($v_binary_data)."'");
    45274633    $v_data = unpack('vdisk/vdisk_start/vdisk_entries/ventries/Vsize/Voffset/vcomment_size', $v_binary_data);
    45284634
    45294635    // ----- Check the global size
    4530     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Comment length : ".$v_data['comment_size']);
    45314636    if (($v_pos + $v_data['comment_size'] + 18) != $v_size) {
    4532       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "The central dir is not at the end of the archive. Some trailing bytes exists after the archive.");
    45334637
    45344638          // ----- Removed in release 2.2 see readme file
     
    45434647
    45444648      // ----- Return
    4545       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    45464649      return PclZip::errorCode();
    45474650          }
     
    45494652
    45504653    // ----- Get comment
    4551     if ($v_data['comment_size'] != 0)
     4654    if ($v_data['comment_size'] != 0) {
    45524655      $p_central_dir['comment'] = fread($this->zip_fd, $v_data['comment_size']);
     4656    }
    45534657    else
    45544658      $p_central_dir['comment'] = '';
    4555     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Comment : \''.$p_central_dir['comment'].'\'');
    45564659
    45574660    $p_central_dir['entries'] = $v_data['entries'];
    4558     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Nb of entries : \''.$p_central_dir['entries'].'\'');
    45594661    $p_central_dir['disk_entries'] = $v_data['disk_entries'];
    4560     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Nb of entries for this disk : \''.$p_central_dir['disk_entries'].'\'');
    45614662    $p_central_dir['offset'] = $v_data['offset'];
    4562     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Offset of Central Dir : \''.$p_central_dir['offset'].'\'');
    45634663    $p_central_dir['size'] = $v_data['size'];
    4564     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Size of Central Dir : \''.$p_central_dir['size'].'\'');
    45654664    $p_central_dir['disk'] = $v_data['disk'];
    4566     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Disk number : \''.$p_central_dir['disk'].'\'');
    45674665    $p_central_dir['disk_start'] = $v_data['disk_start'];
    4568     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Start disk number : \''.$p_central_dir['disk_start'].'\'');
    45694666
    45704667    // TBC
    45714668    //for(reset($p_central_dir); $key = key($p_central_dir); next($p_central_dir)) {
    4572     //  //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "central_dir[$key] = ".$p_central_dir[$key]);
    45734669    //}
    45744670
    45754671    // ----- Return
    4576     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    45774672    return $v_result;
    45784673  }
     
    45874682  function privDeleteByRule(&$p_result_list, &$p_options)
    45884683  {
    4589     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privDeleteByRule", "");
    45904684    $v_result=1;
    45914685    $v_list_detail = array();
    45924686
    45934687    // ----- Open the zip file
    4594     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    45954688    if (($v_result=$this->privOpenFd('rb')) != 1)
    45964689    {
    45974690      // ----- Return
    4598       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    45994691      return $v_result;
    46004692    }
     
    46054697    {
    46064698      $this->privCloseFd();
    4607       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    46084699      return $v_result;
    46094700    }
    46104701
    46114702    // ----- Go to beginning of File
    4612     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
    46134703    @rewind($this->zip_fd);
    4614     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in file : ".ftell($this->zip_fd)."'");
    46154704
    46164705    // ----- Scan all the files
    46174706    // ----- Start at beginning of Central Dir
    46184707    $v_pos_entry = $v_central_dir['offset'];
    4619     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position before rewind : ".ftell($this->zip_fd)."'");
    46204708    @rewind($this->zip_fd);
    4621     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position after rewind : ".ftell($this->zip_fd)."'");
    46224709    if (@fseek($this->zip_fd, $v_pos_entry))
    46234710    {
     
    46294716
    46304717      // ----- Return
    4631       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    46324718      return PclZip::errorCode();
    46334719    }
    4634     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position after fseek : ".ftell($this->zip_fd)."'");
    46354720
    46364721    // ----- Read each entry
     
    46394724    for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
    46404725    {
    4641       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Read next file header entry (index '$i')");
    46424726
    46434727      // ----- Read the file header
     
    46484732        $this->privCloseFd();
    46494733
    4650         //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    46514734        return $v_result;
    46524735      }
    46534736
    4654       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filename (index '$i') : '".$v_header_list[$v_nb_extracted]['stored_filename']."'");
    46554737
    46564738      // ----- Store the index
     
    46634745      if (   (isset($p_options[PCLZIP_OPT_BY_NAME]))
    46644746          && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
    4665           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract with rule 'ByName'");
    46664747
    46674748          // ----- Look if the filename is in the list
    46684749          for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_found); $j++) {
    4669               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Compare with file '".$p_options[PCLZIP_OPT_BY_NAME][$j]."'");
    46704750
    46714751              // ----- Look for a directory
    46724752              if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
    4673                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The searched item is a directory");
    46744753
    46754754                  // ----- Look if the directory is in the filename path
    46764755                  if (   (strlen($v_header_list[$v_nb_extracted]['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
    46774756                      && (substr($v_header_list[$v_nb_extracted]['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
    4678                       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The directory is in the file path");
    46794757                      $v_found = true;
    46804758                  }
    46814759                  elseif (   (($v_header_list[$v_nb_extracted]['external']&0x00000010)==0x00000010) /* Indicates a folder */
    46824760                          && ($v_header_list[$v_nb_extracted]['stored_filename'].'/' == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
    4683                       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The entry is the searched directory");
    46844761                      $v_found = true;
    46854762                  }
     
    46874764              // ----- Look for a filename
    46884765              elseif ($v_header_list[$v_nb_extracted]['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
    4689                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "The file is the right one.");
    46904766                  $v_found = true;
    46914767              }
     
    46944770
    46954771      // ----- Look for extract by ereg rule
     4772      // ereg() is deprecated with PHP 5.3
     4773      /*
    46964774      else if (   (isset($p_options[PCLZIP_OPT_BY_EREG]))
    46974775               && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
    4698           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract by ereg '".$p_options[PCLZIP_OPT_BY_EREG]."'");
    46994776
    47004777          if (ereg($p_options[PCLZIP_OPT_BY_EREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
    4701               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filename match the regular expression");
    47024778              $v_found = true;
    47034779          }
    47044780      }
     4781      */
    47054782
    47064783      // ----- Look for extract by preg rule
    47074784      else if (   (isset($p_options[PCLZIP_OPT_BY_PREG]))
    47084785               && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
    4709           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract with rule 'ByEreg'");
    47104786
    47114787          if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
    4712               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Filename match the regular expression");
    47134788              $v_found = true;
    47144789          }
     
    47184793      else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX]))
    47194794               && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
    4720           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Extract with rule 'ByIndex'");
    47214795
    47224796          // ----- Look if the index is in the list
    47234797          for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_found); $j++) {
    4724               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Look if index '$i' is in [".$p_options[PCLZIP_OPT_BY_INDEX][$j]['start'].",".$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']."]");
    47254798
    47264799              if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
    4727                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Found as part of an index range");
    47284800                  $v_found = true;
    47294801              }
    47304802              if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
    4731                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Do not look this index range for next loop");
    47324803                  $j_start = $j+1;
    47334804              }
    47344805
    47354806              if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
    4736                   //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Index range is greater than index, stop loop");
    47374807                  break;
    47384808              }
     
    47404810      }
    47414811      else {
    4742         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "No argument mean remove all file");
    47434812        $v_found = true;
    47444813      }
     
    47474816      if ($v_found)
    47484817      {
    4749         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$v_header_list[$v_nb_extracted]['stored_filename']."', index '$i' need to be deleted");
    47504818        unset($v_header_list[$v_nb_extracted]);
    47514819      }
    47524820      else
    47534821      {
    4754         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File '".$v_header_list[$v_nb_extracted]['stored_filename']."', index '$i' will not be deleted");
    47554822        $v_nb_extracted++;
    47564823      }
     
    47674834
    47684835        // ----- Open the temporary zip file in write mode
    4769         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary write mode");
    47704836        if (($v_result = $v_temp_zip->privOpenFd('wb')) != 1) {
    47714837            $this->privCloseFd();
    47724838
    47734839            // ----- Return
    4774             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    47754840            return $v_result;
    47764841        }
     
    47784843        // ----- Look which file need to be kept
    47794844        for ($i=0; $i<sizeof($v_header_list); $i++) {
    4780             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Keep entry index '$i' : '".$v_header_list[$i]['filename']."'");
    47814845
    47824846            // ----- Calculate the position of the header
    4783             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Offset='". $v_header_list[$i]['offset']."'");
    4784             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position before rewind : ".ftell($this->zip_fd)."'");
    47854847            @rewind($this->zip_fd);
    4786             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position after rewind : ".ftell($this->zip_fd)."'");
    47874848            if (@fseek($this->zip_fd,  $v_header_list[$i]['offset'])) {
    47884849                // ----- Close the zip file
     
    47954856
    47964857                // ----- Return
    4797                 //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    47984858                return PclZip::errorCode();
    47994859            }
    4800             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position after fseek : ".ftell($this->zip_fd)."'");
    48014860
    48024861            // ----- Read the file header
     
    48094868
    48104869                // ----- Return
    4811                 //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    48124870                return $v_result;
    48134871            }
     
    48284886
    48294887                // ----- Return
    4830                 //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    48314888                return $v_result;
    48324889            }
    4833             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Offset for this file is '".$v_header_list[$i]['offset']."'");
    48344890
    48354891            // ----- Read/write the data block
     
    48414897
    48424898                // ----- Return
    4843                 //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    48444899                return $v_result;
    48454900            }
     
    48484903        // ----- Store the offset of the central dir
    48494904        $v_offset = @ftell($v_temp_zip->zip_fd);
    4850         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "New offset of central dir : $v_offset");
    48514905
    48524906        // ----- Re-Create the Central Dir files header
    4853         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Creates the new central directory");
    48544907        for ($i=0; $i<sizeof($v_header_list); $i++) {
    48554908            // ----- Create the file header
    4856             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Offset of file : ".$v_header_list[$i]['offset']);
    48574909            if (($v_result = $v_temp_zip->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
    48584910                $v_temp_zip->privCloseFd();
     
    48614913
    48624914                // ----- Return
    4863                 //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    48644915                return $v_result;
    48654916            }
     
    48694920        }
    48704921
    4871         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Creates the central directory footer");
    48724922
    48734923        // ----- Zip file comment
     
    48894939
    48904940            // ----- Return
    4891             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    48924941            return $v_result;
    48934942        }
     
    49154964
    49164965        if (($v_result = $this->privOpenFd('wb')) != 1) {
    4917           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    49184966          return $v_result;
    49194967        }
    49204968
    49214969        if (($v_result = $this->privWriteCentralHeader(0, 0, 0, '')) != 1) {
    4922           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    49234970          return $v_result;
    49244971        }
     
    49284975
    49294976    // ----- Return
    4930     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    49314977    return $v_result;
    49324978  }
     
    49484994    $v_result = 1;
    49494995
    4950     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privDirCheck", "entry='$p_dir', is_dir='".($p_is_dir?"true":"false")."'");
    49514996
    49524997    // ----- Remove the final '/'
     
    49555000      $p_dir = substr($p_dir, 0, strlen($p_dir)-1);
    49565001    }
    4957     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Looking for entry '$p_dir'");
    49585002
    49595003    // ----- Check the directory availability
    49605004    if ((is_dir($p_dir)) || ($p_dir == ""))
    49615005    {
    4962       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, "'$p_dir' is a directory");
    49635006      return 1;
    49645007    }
     
    49665009    // ----- Extract parent directory
    49675010    $p_parent_dir = dirname($p_dir);
    4968     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Parent directory is '$p_parent_dir'");
    49695011
    49705012    // ----- Just a check
     
    49765018        if (($v_result = $this->privDirCheck($p_parent_dir)) != 1)
    49775019        {
    4978           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    49795020          return $v_result;
    49805021        }
     
    49835024
    49845025    // ----- Create the directory
    4985     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Create directory '$p_dir'");
    49865026    if (!@mkdir($p_dir, 0777))
    49875027    {
     
    49905030
    49915031      // ----- Return
    4992       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    49935032      return PclZip::errorCode();
    49945033    }
    49955034
    49965035    // ----- Return
    4997     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result, "Directory '$p_dir' created");
    49985036    return $v_result;
    49995037  }
     
    50095047  function privMerge(&$p_archive_to_add)
    50105048  {
    5011     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privMerge", "archive='".$p_archive_to_add->zipname."'");
    50125049    $v_result=1;
    50135050
     
    50155052    if (!is_file($p_archive_to_add->zipname))
    50165053    {
    5017       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Archive to add does not exist. End of merge.");
    50185054
    50195055      // ----- Nothing to merge, so merge is a success
     
    50215057
    50225058      // ----- Return
    5023       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    50245059      return $v_result;
    50255060    }
     
    50285063    if (!is_file($this->zipname))
    50295064    {
    5030       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Archive does not exist, duplicate the archive_to_add.");
    50315065
    50325066      // ----- Do a duplicate
     
    50345068
    50355069      // ----- Return
    5036       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    50375070      return $v_result;
    50385071    }
    50395072
    50405073    // ----- Open the zip file
    5041     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    50425074    if (($v_result=$this->privOpenFd('rb')) != 1)
    50435075    {
    50445076      // ----- Return
    5045       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    50465077      return $v_result;
    50475078    }
     
    50525083    {
    50535084      $this->privCloseFd();
    5054       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    50555085      return $v_result;
    50565086    }
    50575087
    50585088    // ----- Go to beginning of File
    5059     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in zip : ".ftell($this->zip_fd)."'");
    50605089    @rewind($this->zip_fd);
    5061     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in zip : ".ftell($this->zip_fd)."'");
    50625090
    50635091    // ----- Open the archive_to_add file
    5064     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open archive_to_add in binary read mode");
    50655092    if (($v_result=$p_archive_to_add->privOpenFd('rb')) != 1)
    50665093    {
     
    50685095
    50695096      // ----- Return
    5070       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    50715097      return $v_result;
    50725098    }
     
    50795105      $p_archive_to_add->privCloseFd();
    50805106
    5081       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    50825107      return $v_result;
    50835108    }
    50845109
    50855110    // ----- Go to beginning of File
    5086     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in archive_to_add : ".ftell($p_archive_to_add->zip_fd)."'");
    50875111    @rewind($p_archive_to_add->zip_fd);
    5088     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Position in archive_to_add : ".ftell($p_archive_to_add->zip_fd)."'");
    50895112
    50905113    // ----- Creates a temporay file
     
    50925115
    50935116    // ----- Open the temporary file in write mode
    5094     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    50955117    if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
    50965118    {
     
    51015123
    51025124      // ----- Return
    5103       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    51045125      return PclZip::errorCode();
    51055126    }
     
    51115132    {
    51125133      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    5113       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    51145134      $v_buffer = fread($this->zip_fd, $v_read_size);
    51155135      @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
     
    51225142    {
    51235143      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    5124       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    51255144      $v_buffer = fread($p_archive_to_add->zip_fd, $v_read_size);
    51265145      @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
     
    51305149    // ----- Store the offset of the central dir
    51315150    $v_offset = @ftell($v_zip_temp_fd);
    5132     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "New offset of central dir : $v_offset");
    51335151
    51345152    // ----- Copy the block of file headers from the old archive
     
    51375155    {
    51385156      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    5139       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    51405157      $v_buffer = @fread($this->zip_fd, $v_read_size);
    51415158      @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
     
    51485165    {
    51495166      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    5150       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    51515167      $v_buffer = @fread($p_archive_to_add->zip_fd, $v_read_size);
    51525168      @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
     
    51795195
    51805196      // ----- Return
    5181       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    51825197      return $v_result;
    51835198    }
     
    52055220
    52065221    // ----- Return
    5207     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    52085222    return $v_result;
    52095223  }
     
    52185232  function privDuplicate($p_archive_filename)
    52195233  {
    5220     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privDuplicate", "archive_filename='$p_archive_filename'");
    52215234    $v_result=1;
    52225235
     
    52245237    if (!is_file($p_archive_filename))
    52255238    {
    5226       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Archive to duplicate does not exist. End of duplicate.");
    52275239
    52285240      // ----- Nothing to duplicate, so duplicate is a success.
     
    52305242
    52315243      // ----- Return
    5232       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    52335244      return $v_result;
    52345245    }
    52355246
    52365247    // ----- Open the zip file
    5237     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    52385248    if (($v_result=$this->privOpenFd('wb')) != 1)
    52395249    {
    52405250      // ----- Return
    5241       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    52425251      return $v_result;
    52435252    }
    52445253
    52455254    // ----- Open the temporary file in write mode
    5246     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Open file in binary read mode");
    52475255    if (($v_zip_temp_fd = @fopen($p_archive_filename, 'rb')) == 0)
    52485256    {
     
    52525260
    52535261      // ----- Return
    5254       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    52555262      return PclZip::errorCode();
    52565263    }
     
    52625269    {
    52635270      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    5264       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read $v_read_size bytes");
    52655271      $v_buffer = fread($v_zip_temp_fd, $v_read_size);
    52665272      @fwrite($this->zip_fd, $v_buffer, $v_read_size);
     
    52755281
    52765282    // ----- Return
    5277     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    52785283    return $v_result;
    52795284  }
     
    53155320
    53165321  // --------------------------------------------------------------------------------
    5317   // Function : privDecrypt()
    5318   // Description :
    5319   // Parameters :
    5320   // Return Values :
    5321   // --------------------------------------------------------------------------------
    5322   function privDecrypt($p_encryption_header, &$p_buffer, $p_size, $p_crc)
    5323   {
    5324     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privDecrypt', "size=".$p_size."");
    5325     $v_result=1;
    5326    
    5327     // ----- To Be Modified ;-)
    5328     $v_pwd = "test";
    5329    
    5330     $p_buffer = PclZipUtilZipDecrypt($p_buffer, $p_size, $p_encryption_header,
    5331                                          $p_crc, $v_pwd);
    5332    
    5333     // ----- Return
    5334     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    5335     return $v_result;
    5336   }
    5337   // --------------------------------------------------------------------------------
    5338 
    5339   // --------------------------------------------------------------------------------
    53405322  // Function : privDisableMagicQuotes()
    53415323  // Description :
     
    53455327  function privDisableMagicQuotes()
    53465328  {
    5347     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privDisableMagicQuotes', "");
    53485329    $v_result=1;
    53495330
     
    53515332    if (   (!function_exists("get_magic_quotes_runtime"))
    53525333            || (!function_exists("set_magic_quotes_runtime"))) {
    5353       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Functions *et_magic_quotes_runtime are not supported");
    5354       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    53555334      return $v_result;
    53565335        }
     
    53585337    // ----- Look if already done
    53595338    if ($this->magic_quotes_status != -1) {
    5360       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "magic_quote already disabled");
    5361       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    53625339      return $v_result;
    53635340        }
     
    53655342        // ----- Get and memorize the magic_quote value
    53665343        $this->magic_quotes_status = @get_magic_quotes_runtime();
    5367     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Current magic_quotes_runtime status is '".($this->magic_quotes_status==0?'disable':'enable')."'");
    53685344
    53695345        // ----- Disable magic_quotes
    53705346        if ($this->magic_quotes_status == 1) {
    5371       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Disable magic_quotes");
    53725347          @set_magic_quotes_runtime(0);
    53735348        }
    53745349
    53755350    // ----- Return
    5376     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    53775351    return $v_result;
    53785352  }
     
    53875361  function privSwapBackMagicQuotes()
    53885362  {
    5389     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privSwapBackMagicQuotes', "");
    53905363    $v_result=1;
    53915364
     
    53935366    if (   (!function_exists("get_magic_quotes_runtime"))
    53945367            || (!function_exists("set_magic_quotes_runtime"))) {
    5395       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Functions *et_magic_quotes_runtime are not supported");
    5396       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    53975368      return $v_result;
    53985369        }
     
    54005371    // ----- Look if something to do
    54015372    if ($this->magic_quotes_status != -1) {
    5402       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "magic_quote not modified");
    5403       //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    54045373      return $v_result;
    54055374        }
     
    54075376        // ----- Swap back magic_quotes
    54085377        if ($this->magic_quotes_status == 1) {
    5409       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Enable back magic_quotes");
    54105378          @set_magic_quotes_runtime($this->magic_quotes_status);
    54115379        }
    54125380
    54135381    // ----- Return
    5414     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    54155382    return $v_result;
    54165383  }
     
    54295396  function PclZipUtilPathReduction($p_dir)
    54305397  {
    5431     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZipUtilPathReduction", "dir='$p_dir'");
    54325398    $v_result = "";
    54335399
     
    54565422                        // TBC
    54575423                        $v_result = $p_dir;
    5458                 //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Invalid path is unchanged");
    54595424                $v_skip = 0;
    54605425                    }
     
    54915456
    54925457    // ----- Return
    5493     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    54945458    return $v_result;
    54955459  }
     
    55135477  function PclZipUtilPathInclusion($p_dir, $p_path)
    55145478  {
    5515     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZipUtilPathInclusion", "dir='$p_dir', path='$p_path'");
    55165479    $v_result = 1;
    55175480   
     
    55205483        || ((strlen($p_dir) >=2) && (substr($p_dir, 0, 2) == './'))) {
    55215484      $p_dir = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_dir, 1);
    5522       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Replacing ./ by full path in p_dir '".$p_dir."'");
    55235485    }
    55245486    if (   ($p_path == '.')
    55255487        || ((strlen($p_path) >=2) && (substr($p_path, 0, 2) == './'))) {
    55265488      $p_path = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_path, 1);
    5527       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Replacing ./ by full path in p_path '".$p_path."'");
    55285489    }
    55295490
     
    55385499    $j = 0;
    55395500    while (($i < $v_list_dir_size) && ($j < $v_list_path_size) && ($v_result)) {
    5540       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Working on dir($i)='".$v_list_dir[$i]."' and path($j)='".$v_list_path[$j]."'");
    55415501
    55425502      // ----- Look for empty dir (path reduction)
     
    55525512      // ----- Compare the items
    55535513      if (($v_list_dir[$i] != $v_list_path[$j]) && ($v_list_dir[$i] != '') && ( $v_list_path[$j] != ''))  {
    5554         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Items ($i,$j) are different");
    55555514        $v_result = 0;
    55565515      }
     
    55635522    // ----- Look if everything seems to be the same
    55645523    if ($v_result) {
    5565       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Look for tie break");
    55665524      // ----- Skip all the empty items
    55675525      while (($j < $v_list_path_size) && ($v_list_path[$j] == '')) $j++;
    55685526      while (($i < $v_list_dir_size) && ($v_list_dir[$i] == '')) $i++;
    5569       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Looking on dir($i)='".($i < $v_list_dir_size?$v_list_dir[$i]:'')."' and path($j)='".($j < $v_list_path_size?$v_list_path[$j]:'')."'");
    55705527
    55715528      if (($i >= $v_list_dir_size) && ($j >= $v_list_path_size)) {
     
    55805537
    55815538    // ----- Return
    5582     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    55835539    return $v_result;
    55845540  }
     
    55985554  function PclZipUtilCopyBlock($p_src, $p_dest, $p_size, $p_mode=0)
    55995555  {
    5600     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZipUtilCopyBlock", "size=$p_size, mode=$p_mode");
    56015556    $v_result = 1;
    56025557
    56035558    if ($p_mode==0)
    56045559    {
    5605       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Src offset before read :".(@ftell($p_src)));
    5606       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Dest offset before write :".(@ftell($p_dest)));
    56075560      while ($p_size != 0)
    56085561      {
    56095562        $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
    5610         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    56115563        $v_buffer = @fread($p_src, $v_read_size);
    56125564        @fwrite($p_dest, $v_buffer, $v_read_size);
    56135565        $p_size -= $v_read_size;
    56145566      }
    5615       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Src offset after read :".(@ftell($p_src)));
    5616       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Dest offset after write :".(@ftell($p_dest)));
    56175567    }
    56185568    else if ($p_mode==1)
     
    56215571      {
    56225572        $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
    5623         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    56245573        $v_buffer = @gzread($p_src, $v_read_size);
    56255574        @fwrite($p_dest, $v_buffer, $v_read_size);
     
    56325581      {
    56335582        $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
    5634         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    56355583        $v_buffer = @fread($p_src, $v_read_size);
    56365584        @gzwrite($p_dest, $v_buffer, $v_read_size);
     
    56435591      {
    56445592        $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
    5645         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read $v_read_size bytes");
    56465593        $v_buffer = @gzread($p_src, $v_read_size);
    56475594        @gzwrite($p_dest, $v_buffer, $v_read_size);
     
    56515598
    56525599    // ----- Return
    5653     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    56545600    return $v_result;
    56555601  }
     
    56705616  function PclZipUtilRename($p_src, $p_dest)
    56715617  {
    5672     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZipUtilRename", "source=$p_src, destination=$p_dest");
    56735618    $v_result = 1;
    56745619
    56755620    // ----- Try to rename the files
    56765621    if (!@rename($p_src, $p_dest)) {
    5677       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Fail to rename file, try copy+unlink");
    56785622
    56795623      // ----- Try to copy & unlink the src
    56805624      if (!@copy($p_src, $p_dest)) {
    5681         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Fail to copy file");
    56825625        $v_result = 0;
    56835626      }
    56845627      else if (!@unlink($p_src)) {
    5685         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Fail to unlink old filename");
    56865628        $v_result = 0;
    56875629      }
     
    56895631
    56905632    // ----- Return
    5691     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    56925633    return $v_result;
    56935634  }
     
    57055646  function PclZipUtilOptionText($p_option)
    57065647  {
    5707     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZipUtilOptionText", "option='".$p_option."'");
    57085648   
    57095649    $v_list = get_defined_constants();
    57105650    for (reset($v_list); $v_key = key($v_list); next($v_list)) {
    5711           $v_prefix = substr($v_key, 0, 10);
    5712           if ((   ($v_prefix == 'PCLZIP_OPT')
    5713          || ($v_prefix == 'PCLZIP_CB_')
    5714          || ($v_prefix == 'PCLZIP_ATT'))
    5715               && ($v_list[$v_key] == $p_option)) {
    5716           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_key);
    5717           return $v_key;
     5651            $v_prefix = substr($v_key, 0, 10);
     5652            if ((   ($v_prefix == 'PCLZIP_OPT')
     5653           || ($v_prefix == 'PCLZIP_CB_')
     5654           || ($v_prefix == 'PCLZIP_ATT'))
     5655                && ($v_list[$v_key] == $p_option)) {
     5656        return $v_key;
    57185657            }
    57195658    }
     
    57215660    $v_result = 'Unknown';
    57225661
    5723     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    57245662    return $v_result;
    57255663  }
Note: See TracChangeset for help on using the changeset viewer.