WordPress.org

Make WordPress Core

Changeset 11056


Ignore:
Timestamp:
04/22/09 18:04:49 (5 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.