WordPress.org

Make WordPress Core

Changeset 11056


Ignore:
Timestamp:
04/22/2009 06:04:49 PM (9 years ago)
Author:
ryan
Message:

Update pclzip to 2.8 and apply x64 patch. Props demetris. fixes #9615

File:
1 edited

Legend:

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

    r11038 r11056  
    11<?php
    22// --------------------------------------------------------------------------------
    3 // PhpConcept Library - Zip Module 2.7
     3// PhpConcept Library - Zip Module 2.8
    44// --------------------------------------------------------------------------------
    55// License GNU/LGPL - Vincent Blavet - March 2006
     
    2323//
    2424// --------------------------------------------------------------------------------
    25 // $Id: pclzip.lib.php,v 1.50 2009/03/24 17:13:52 vblavet Exp $
     25// $Id: pclzip.lib.php,v 1.55 2009/04/22 07:38:36 vblavet Exp $
    2626// --------------------------------------------------------------------------------
    2727
     
    6767  }
    6868
     69  // ----- Optional threshold ratio for use of temporary files
     70  //       Pclzip sense the size of the file to add/extract and decide to
     71  //       use or not temporary file. The algorythm is looking for
     72  //       memory_limit of PHP and apply a ratio.
     73  //       threshold = memory_limit * ratio.
     74  //       Recommended values are under 0.5. Default 0.47.
     75  //       Samples :
     76  // define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.5 );
     77  if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {
     78    define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );
     79  }
     80
    6981// --------------------------------------------------------------------------------
    7082// ***** UNDER THIS LINE NOTHING NEEDS TO BE MODIFIED *****
     
    7284
    7385  // ----- Global variables
    74   $g_pclzip_version = "2.7";
     86  $g_pclzip_version = "2.8";
    7587
    7688  // ----- Error codes
     
    135147  //define( 'PCLZIP_OPT_CRYPT', 77018 );
    136148  define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );
    137   define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 );
    138   define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 );
    139   define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 );
     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
    140155 
    141156  // ----- File description attributes
     
    295310                                                   PCLZIP_OPT_NO_COMPRESSION => 'optional',
    296311                                                   PCLZIP_OPT_COMMENT => 'optional',
    297                                                    PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD => 'optional',
    298                                                    PCLZIP_OPT_ADD_TEMP_FILE_ON => 'optional',
    299                                                    PCLZIP_OPT_ADD_TEMP_FILE_OFF => 'optional'
     312                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     313                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     314                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    300315                                                   //, PCLZIP_OPT_CRYPT => 'optional'
    301316                                             ));
     
    329344   
    330345    // ----- Look for default option values
    331     if (!isset($v_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
    332       $this->privOptionDefaultThreshold($v_options);
    333     }
     346    $this->privOptionDefaultThreshold($v_options);
    334347
    335348    // ----- Init
     
    494507                                                   PCLZIP_OPT_ADD_COMMENT => 'optional',
    495508                                                   PCLZIP_OPT_PREPEND_COMMENT => 'optional',
    496                                                    PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD => 'optional',
    497                                                    PCLZIP_OPT_ADD_TEMP_FILE_ON => 'optional',
    498                                                    PCLZIP_OPT_ADD_TEMP_FILE_OFF => 'optional'
     509                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     510                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     511                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    499512                                                   //, PCLZIP_OPT_CRYPT => 'optional'
    500513                                                   ));
     
    530543
    531544    // ----- Look for default option values
    532     if (!isset($v_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
    533       $this->privOptionDefaultThreshold($v_options);
    534     }
     545    $this->privOptionDefaultThreshold($v_options);
    535546
    536547    // ----- Init
     
    771782                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'
    772783                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
    773                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional'
     784                                                   ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
     785                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     786                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     787                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    774788                                                    ));
    775789        if ($v_result != 1) {
     
    820834      }
    821835    }
     836
     837    // ----- Look for default option values
     838    $this->privOptionDefaultThreshold($v_options);
    822839
    823840    // ----- Trace
     
    931948                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'
    932949                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
    933                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional'
     950                                                   ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
     951                                                   PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
     952                                                   PCLZIP_OPT_TEMP_FILE_ON => 'optional',
     953                                                   PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
    934954                                                   ));
    935955        if ($v_result != 1) {
     
    10031023    }
    10041024    $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
     1025
     1026    // ----- Look for default option values
     1027    $this->privOptionDefaultThreshold($v_options);
    10051028
    10061029    // ----- Call the extracting fct
     
    15231546        break;
    15241547
    1525         case PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD :
     1548        case PCLZIP_OPT_TEMP_FILE_THRESHOLD :
    15261549          // ----- Check the number of parameters
    15271550          if (($i+1) >= $p_size) {
     
    15321555         
    15331556          // ----- Check for incompatible options
    1534           if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_OFF])) {
    1535             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_OFF'");
     1557          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
     1558            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
    15361559            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15371560            return PclZip::errorCode();
     
    15521575        break;
    15531576
    1554         case PCLZIP_OPT_ADD_TEMP_FILE_ON :
     1577        case PCLZIP_OPT_TEMP_FILE_ON :
    15551578          // ----- Check for incompatible options
    1556           if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_OFF])) {
    1557             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_OFF'");
     1579          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
     1580            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
    15581581            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15591582            return PclZip::errorCode();
     
    15641587        break;
    15651588
    1566         case PCLZIP_OPT_ADD_TEMP_FILE_OFF :
     1589        case PCLZIP_OPT_TEMP_FILE_OFF :
    15671590          // ----- Check for incompatible options
    1568           if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_ON])) {
    1569             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_ON'");
     1591          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_ON])) {
     1592            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_ON'");
    15701593            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15711594            return PclZip::errorCode();
    15721595          }
    15731596          // ----- Check for incompatible options
    1574           if (isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
    1575             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD'");
     1597          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
     1598            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_THRESHOLD'");
    15761599            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
    15771600            return PclZip::errorCode();
     
    19081931   
    19091932    // ----- Look for default values
    1910     if (!isset($v_result_list[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])) {
     1933    if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
    19111934      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Calculate auto threshold");
    19121935     
     
    19291952    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, "PclZip::privOptionDefaultThreshold", "");
    19301953    $v_result=1;
     1954   
     1955    if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     1956        || isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) {
     1957      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     1958      return $v_result;
     1959    }
    19311960   
    19321961    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Create an auto-threshold for use of temporay files");
     
    19451974        $v_memory_limit = $v_memory_limit*1024;
    19461975           
    1947     $p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD] = floor($v_memory_limit/2);
     1976    $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO);
    19481977   
    1949     //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Threshold value is : ".$p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD]." bytes");
     1978    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Current memory usage : ".memory_get_usage(TRUE)." bytes");
     1979    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Threshold value is : ".$p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]." bytes");
    19501980
    19511981    // ----- Sanity check : No threshold if value lower than 1M
    1952     if ($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD] < 1048576) {
    1953       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Unset the threshold (value ".$p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD].") because under 1Mo sanity check)");
    1954       unset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD]);
     1982    if ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] < 1048576) {
     1983      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Unset the threshold (value ".$p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD].") because under 1Mo sanity check)");
     1984      unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
    19551985    }
    19561986         
     
    27752805    // ----- Look for filetime
    27762806    if (isset($p_filedescr['mtime'])) {
     2807      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3,"Overload mtime value with :'".$p_filedescr['mtime']."'");
    27772808      $p_header['mtime'] = $p_filedescr['mtime'];
    27782809    }
    27792810    else if ($p_filedescr['type'] == 'virtual_file') {
    27802811      $p_header['mtime'] = time();
     2812      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, "Virtual file : use current time '".$p_header['mtime']."' for mtime value.");
    27812813    }
    27822814    else {
     
    28362868      if ($p_filedescr['type'] == 'file') {
    28372869        // ----- Look for using temporary file to zip
    2838         if ( (!isset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_OFF]))
    2839             && (isset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_ON])
    2840                 || (isset($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD])
    2841                     && ($p_options[PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
     2870        if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
     2871            && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
     2872                || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     2873                    && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
    28422874          $v_result = $this->privAddFileUsingTempFile($p_filedescr, $p_header, $p_options);
    2843           if ($v_result >= PCLZIP_ERR_NO_ERROR) {
     2875          if ($v_result < PCLZIP_ERR_NO_ERROR) {
    28442876            return $v_result;
    28452877          }
     
    28482880        // ----- Use "in memory" zip algo
    28492881        else {
    2850          
    2851         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a file");
     2882          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2,"In memory compression.");     
     2883          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2,"Current memory usage : ".memory_get_usage(TRUE)." bytes");     
     2884          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2,"Current memory peak : ".memory_get_peak_usage(TRUE)." bytes");     
     2885          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "'".$p_filename."' is a file");
    28522886
    28532887        // ----- Open the source file
     
    28602894        // ----- Read the file content
    28612895        $v_content = @fread($v_file, $p_header['size']);
     2896        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2,"Memory usage after reading file : ".memory_get_usage(TRUE)." bytes");     
     2897        //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2,"Memory peak after reading file : ".memory_get_peak_usage(TRUE)." bytes");     
    28622898
    28632899        // ----- Close the file
     
    28802916          // ----- Compress the content
    28812917          $v_content = @gzdeflate($v_content);
     2918          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2,"Memory usage after gzdeflate : ".memory_get_usage(TRUE)." bytes");     
     2919          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2,"Memory peak after gzdeflate : ".memory_get_peak_usage(TRUE)." bytes");     
    28822920
    28832921          // ----- Set header parameters
     
    28862924        }
    28872925       
    2888         // ----- Look for encryption
    2889         /*
    2890         if ((isset($p_options[PCLZIP_OPT_CRYPT]))
    2891             && ($p_options[PCLZIP_OPT_CRYPT] != "")) {
    2892           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File need to be crypted ....");
    2893          
    2894           // Should be a random header
    2895           $v_header = 'xxxxxxxxxxxx';
    2896           $v_content_compressed = PclZipUtilZipEncrypt($v_content_compressed,
    2897                                                    $p_header['compressed_size'],
    2898                                                    $v_header,
    2899                                                    $p_header['crc'],
    2900                                                    "test");
    2901                                                    
    2902           $p_header['compressed_size'] += 12;
    2903           $p_header['flag'] = 1;
    2904          
    2905           // ----- Add the header to the data
    2906           $v_content_compressed = $v_header.$v_content_compressed;
    2907           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size after header : ".strlen($v_content_compressed)."");
    2908         }
    2909         */
    2910 
    29112926        // ----- Call the header generation
    29122927        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     
    29512966        }
    29522967       
    2953         // ----- Look for encryption
    2954         /*
    2955         if ((isset($p_options[PCLZIP_OPT_CRYPT]))
    2956             && ($p_options[PCLZIP_OPT_CRYPT] != "")) {
    2957           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File need to be crypted ....");
    2958          
    2959           // Should be a random header
    2960           $v_header = 'xxxxxxxxxxxx';
    2961           $v_content_compressed = PclZipUtilZipEncrypt($v_content_compressed,
    2962                                                    $p_header['compressed_size'],
    2963                                                    $v_header,
    2964                                                    $p_header['crc'],
    2965                                                    "test");
    2966                                                    
    2967           $p_header['compressed_size'] += 12;
    2968           $p_header['flag'] = 1;
    2969          
    2970           // ----- Add the header to the data
    2971           $v_content_compressed = $v_header.$v_content_compressed;
    2972           //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size after header : ".strlen($v_content_compressed)."");
    2973         }
    2974         */
    2975 
    29762968        // ----- Call the header generation
    29772969        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     
    30703062    while ($v_size != 0) {
    30713063      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    3072       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read $v_read_size bytes");
    3073       $v_buffer = fread($v_file, $v_read_size);
     3064      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read ".$v_read_size." bytes");
     3065      $v_buffer = @fread($v_file, $v_read_size);
    30743066      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
    30753067      @gzputs($v_file_compressed, $v_buffer, $v_read_size);
     
    31503142    {
    31513143      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
    3152       //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read $v_read_size bytes");
    3153       $v_buffer = fread($v_file_compressed, $v_read_size);
     3144      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 4, "Read ".$v_read_size." bytes");
     3145      $v_buffer = @fread($v_file_compressed, $v_read_size);
    31543146      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
    31553147      @fwrite($this->zip_fd, $v_buffer, $v_read_size);
     
    35423534
    35433535    // ----- Get the interesting attributes
    3544     $p_info['filename'] = $p_header['filename'];
    3545     $p_info['stored_filename'] = $p_header['stored_filename'];
     3536    $v_temp_path = PclZipUtilPathReduction($p_header['filename']);
     3537    $p_info['filename'] = $v_temp_path;
     3538    $v_temp_path = PclZipUtilPathReduction($p_header['stored_filename']);
     3539    $p_info['stored_filename'] = $v_temp_path;
    35463540    $p_info['size'] = $p_header['size'];
    35473541    $p_info['compressed_size'] = $p_header['compressed_size'];
     
    42014195          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Extracting an un-compressed file");
    42024196
    4203           // ----- Opening destination file
     4197              // ----- Opening destination file
    42044198          if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0)
    42054199          {
     
    42444238          // Need to be finished
    42454239          if (($p_entry['flag'] & 1) == 1) {
    4246               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File is encrypted");
    4247             /*
    4248               // ----- Read the encryption header
    4249               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read 12 encryption header bytes");
    4250               $v_encryption_header = @fread($this->zip_fd, 12);
     4240            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "File is encrypted");
     4241            PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION, 'File \''.$p_entry['filename'].'\' is encrypted. Encrypted files are not supported.');
     4242            //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     4243            return PclZip::errorCode();
     4244          }
     4245
     4246
     4247          // ----- Look for using temporary file to unzip
     4248          if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
     4249              && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
     4250                  || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     4251                      && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_entry['size'])) ) ) {
     4252            $v_result = $this->privExtractFileUsingTempFile($p_entry, $p_options);
     4253            if ($v_result < PCLZIP_ERR_NO_ERROR) {
     4254              return $v_result;
     4255            }
     4256          }
     4257         
     4258          // ----- Look for extract in memory
     4259          else {
     4260
     4261            //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read '".$p_entry['compressed_size']."' compressed bytes");
     4262         
     4263            // ----- Read the compressed file in a buffer (one shot)
     4264            $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
     4265           
     4266            // ----- Decompress the file
     4267            $v_file_content = @gzinflate($v_buffer);
     4268            unset($v_buffer);
     4269            if ($v_file_content === FALSE) {
     4270              //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to inflate compressed file");
     4271 
     4272              // ----- Change the file status
     4273              // TBC
     4274              $p_entry['status'] = "error";
    42514275             
    4252               // ----- Read the encrypted & compressed file in a buffer
    4253               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read '".($p_entry['compressed_size']-12)."' compressed & encrypted bytes");
    4254               $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']-12);
    4255              
    4256               // ----- Decrypt the buffer
    4257               $this->privDecrypt($v_encryption_header, $v_buffer,
    4258                                  $p_entry['compressed_size']-12, $p_entry['crc']);
    4259               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Buffer is '".$v_buffer."'");
    4260               */
    4261           }
    4262           else {
    4263               //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 5, "Read '".$p_entry['compressed_size']."' compressed bytes");
    4264               // ----- Read the compressed file in a buffer (one shot)
    4265               $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
    4266           }
    4267          
    4268           // ----- Decompress the file
    4269           $v_file_content = @gzinflate($v_buffer);
    4270           unset($v_buffer);
    4271           if ($v_file_content === FALSE) {
    4272             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Unable to inflate compressed file");
    4273 
    4274             // ----- Change the file status
    4275             // TBC
    4276             $p_entry['status'] = "error";
     4276              //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     4277              return $v_result;
     4278            }
    42774279           
    4278             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    4279             return $v_result;
    4280           }
    4281          
    4282           // ----- Opening destination file
    4283           if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
    4284             //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Error while opening '".$p_entry['filename']."' in write binary mode");
    4285 
    4286             // ----- Change the file status
    4287             $p_entry['status'] = "write_error";
    4288 
    4289             //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    4290             return $v_result;
    4291           }
    4292 
    4293           // ----- Write the uncompressed data
    4294           @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
    4295           unset($v_file_content);
    4296 
    4297           // ----- Closing the destination file
    4298           @fclose($v_dest_file);
     4280            // ----- Opening destination file
     4281            if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
     4282              //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Error while opening '".$p_entry['filename']."' in write binary mode");
     4283 
     4284              // ----- Change the file status
     4285              $p_entry['status'] = "write_error";
     4286 
     4287              //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     4288              return $v_result;
     4289            }
     4290 
     4291            // ----- Write the uncompressed data
     4292            @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
     4293            unset($v_file_content);
     4294 
     4295            // ----- Closing the destination file
     4296            @fclose($v_dest_file);
     4297           
     4298          }
    42994299
    43004300          // ----- Change the file mtime
     
    43394339    }
    43404340
     4341    // ----- Return
     4342    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     4343    return $v_result;
     4344  }
     4345  // --------------------------------------------------------------------------------
     4346
     4347  // --------------------------------------------------------------------------------
     4348  // Function : privExtractFileUsingTempFile()
     4349  // Description :
     4350  // Parameters :
     4351  // Return Values :
     4352  // --------------------------------------------------------------------------------
     4353  function privExtractFileUsingTempFile(&$p_entry, &$p_options)
     4354  {
     4355    //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privExtractFileUsingTempFile', "filename='".$p_entry['filename']."'");
     4356    $v_result=1;
     4357       
     4358    // ----- Creates a temporary file
     4359    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
     4360    if (($v_dest_file = @fopen($v_gzip_temp_name, "wb")) == 0) {
     4361      fclose($v_file);
     4362      PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
     4363      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     4364      return PclZip::errorCode();
     4365    }
     4366
     4367    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Start extraction of '".$p_entry['filename']."'");
     4368
     4369    // ----- Write gz file format header
     4370    $v_binary_data = pack('va1a1Va1a1', 0x8b1f, Chr($p_entry['compression']), Chr(0x00), time(), Chr(0x00), Chr(3));
     4371    @fwrite($v_dest_file, $v_binary_data, 10);
     4372
     4373    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     4374    $v_size = $p_entry['compressed_size'];
     4375    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Compressed Size :".$v_size."");
     4376    while ($v_size != 0)
     4377    {
     4378      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     4379      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read ".$v_read_size." bytes");
     4380      $v_buffer = @fread($this->zip_fd, $v_read_size);
     4381      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     4382      @fwrite($v_dest_file, $v_buffer, $v_read_size);
     4383      $v_size -= $v_read_size;
     4384    }
     4385
     4386    // ----- Write gz file format footer
     4387    $v_binary_data = pack('VV', $p_entry['crc'], $p_entry['size']);
     4388    @fwrite($v_dest_file, $v_binary_data, 8);
     4389
     4390    // ----- Close the temporary file
     4391    @fclose($v_dest_file);
     4392
     4393    // ----- Opening destination file
     4394    if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
     4395      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Error while opening '".$p_entry['filename']."' in write binary mode");
     4396      $p_entry['status'] = "write_error";
     4397      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     4398      return $v_result;
     4399    }
     4400
     4401    // ----- Open the temporary gz file
     4402    if (($v_src_file = @gzopen($v_gzip_temp_name, 'rb')) == 0) {
     4403      @fclose($v_dest_file);
     4404      $p_entry['status'] = "read_error";
     4405      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
     4406      //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, PclZip::errorCode(), PclZip::errorInfo());
     4407      return PclZip::errorCode();
     4408    }
     4409
     4410    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, 'File size is '.filesize($v_gzip_temp_name));
     4411    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Reading '".$p_entry['size']."' bytes");
     4412
     4413    // ----- Read the file by PCLZIP_READ_BLOCK_SIZE octets blocks
     4414    $v_size = $p_entry['size'];
     4415    //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Size :".$v_size."");
     4416    while ($v_size != 0) {
     4417      $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
     4418      //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 2, "Read ".$v_read_size." bytes");
     4419      $v_buffer = @gzread($v_src_file, $v_read_size);
     4420      //$v_binary_data = pack('a'.$v_read_size, $v_buffer);
     4421      @fwrite($v_dest_file, $v_buffer, $v_read_size);
     4422      $v_size -= $v_read_size;
     4423    }
     4424    @fclose($v_dest_file);
     4425    @gzclose($v_src_file);
     4426
     4427    // ----- Delete the temporary file
     4428    @unlink($v_gzip_temp_name);
     4429   
    43414430    // ----- Return
    43424431    //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
     
    48134902    $v_result=1;
    48144903
    4815     // ----- Check the static values
    4816     // TBC
    4817     if ($p_local_header['filename'] != $p_central_header['filename']) {
    4818         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "filename" : TBC To Be Completed');
    4819     }
    4820     if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
    4821         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "version_extracted" : TBC To Be Completed');
    4822     }
    4823     if ($p_local_header['flag'] != $p_central_header['flag']) {
    4824         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "flag" : TBC To Be Completed');
    4825     }
    4826     if ($p_local_header['compression'] != $p_central_header['compression']) {
    4827         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "compression" : TBC To Be Completed');
    4828     }
    4829     if ($p_local_header['mtime'] != $p_central_header['mtime']) {
    4830         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "mtime" : TBC To Be Completed');
    4831     }
    4832     if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
    4833         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "filename_len" : TBC To Be Completed');
    4834     }
    4835 
    4836     // ----- Look for flag bit 3
    4837     if (($p_local_header['flag'] & 8) == 8) {
    4838         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Purpose bit flag bit 3 set !');
    4839         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'File size, compression size and crc found in central header');
    4840         $p_local_header['size'] = $p_central_header['size'];
    4841         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Size : \''.$p_local_header['size'].'\'');
    4842         $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
    4843         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Compressed Size : \''.$p_local_header['compressed_size'].'\'');
    4844         $p_local_header['crc'] = $p_central_header['crc'];
    4845         //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'CRC : \''.sprintf("0x%X", $p_local_header['crc']).'\'');
    4846     }
     4904    // ----- Check the static values
     4905    // TBC
     4906    if ($p_local_header['filename'] != $p_central_header['filename']) {
     4907          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "filename" : TBC To Be Completed');
     4908    }
     4909    if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
     4910          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "version_extracted" : TBC To Be Completed');
     4911    }
     4912    if ($p_local_header['flag'] != $p_central_header['flag']) {
     4913          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "flag" : TBC To Be Completed');
     4914    }
     4915    if ($p_local_header['compression'] != $p_central_header['compression']) {
     4916          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "compression" : TBC To Be Completed');
     4917    }
     4918    if ($p_local_header['mtime'] != $p_central_header['mtime']) {
     4919          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "mtime" : TBC To Be Completed');
     4920    }
     4921    if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
     4922          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Bad check "filename_len" : TBC To Be Completed');
     4923    }
     4924 
     4925    // ----- Look for flag bit 3
     4926    if (($p_local_header['flag'] & 8) == 8) {
     4927          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Purpose bit flag bit 3 set !');
     4928          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'File size, compression size and crc found in central header');
     4929          $p_local_header['size'] = $p_central_header['size'];
     4930          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Size : \''.$p_local_header['size'].'\'');
     4931          $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
     4932          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'Compressed Size : \''.$p_local_header['compressed_size'].'\'');
     4933          $p_local_header['crc'] = $p_central_header['crc'];
     4934          //--(MAGIC-PclTrace)--//PclTraceFctMessage(__FILE__, __LINE__, 3, 'CRC : \''.sprintf("0x%X", $p_local_header['crc']).'\'');
     4935    }
    48474936
    48484937    // ----- Return
     
    49375026
    49385027        // -----  Add the byte
    4939         $v_bytes = ($v_bytes << 8) | Ord($v_byte);
     5028        // $v_bytes = ($v_bytes << 8) | Ord($v_byte);
     5029        // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number
     5030        // Otherwise on systems where we have 64bit integers the check below for the magic number will fail.
     5031        $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte);
    49405032
    49415033        // ----- Compare the bytes
     
    57715863      $this->error_string = '';
    57725864    }
    5773   }
    5774   // --------------------------------------------------------------------------------
    5775 
    5776   // --------------------------------------------------------------------------------
    5777   // Function : privDecrypt()
    5778   // Description :
    5779   // Parameters :
    5780   // Return Values :
    5781   // --------------------------------------------------------------------------------
    5782   function privDecrypt($p_encryption_header, &$p_buffer, $p_size, $p_crc)
    5783   {
    5784     //--(MAGIC-PclTrace)--//PclTraceFctStart(__FILE__, __LINE__, 'PclZip::privDecrypt', "size=".$p_size."");
    5785     $v_result=1;
    5786    
    5787     // ----- To Be Modified ;-)
    5788     $v_pwd = "test";
    5789    
    5790     $p_buffer = PclZipUtilZipDecrypt($p_buffer, $p_size, $p_encryption_header,
    5791                                      $p_crc, $v_pwd);
    5792    
    5793     // ----- Return
    5794     //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_result);
    5795     return $v_result;
    57965865  }
    57975866  // --------------------------------------------------------------------------------
     
    61696238    $v_list = get_defined_constants();
    61706239    for (reset($v_list); $v_key = key($v_list); next($v_list)) {
    6171       $v_prefix = substr($v_key, 0, 10);
    6172       if ((   ($v_prefix == 'PCLZIP_OPT')
    6173          || ($v_prefix == 'PCLZIP_CB_')
    6174          || ($v_prefix == 'PCLZIP_ATT'))
    6175           && ($v_list[$v_key] == $p_option)) {
    6176           //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_key);
    6177           return $v_key;
     6240        $v_prefix = substr($v_key, 0, 10);
     6241        if ((   ($v_prefix == 'PCLZIP_OPT')
     6242           || ($v_prefix == 'PCLZIP_CB_')
     6243           || ($v_prefix == 'PCLZIP_ATT'))
     6244            && ($v_list[$v_key] == $p_option)) {
     6245        //--(MAGIC-PclTrace)--//PclTraceFctEnd(__FILE__, __LINE__, $v_key);
     6246        return $v_key;
    61786247        }
    61796248    }
Note: See TracChangeset for help on using the changeset viewer.