WordPress.org

Make WordPress Core


Ignore:
Timestamp:
10/15/2009 08:26:21 PM (10 years ago)
Author:
ryan
Message:

Associate subdirector of whitespace trims trailing whites with pinking shears.

File:
1 edited

Legend:

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

    r11993 r12042  
    3030    define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );
    3131  }
    32  
     32
    3333  // ----- File list separator
    3434  // In version 1.x of PclZip, the separator for file list is a space
     
    6969  // ----- Optional threshold ratio for use of temporary files
    7070  //       Pclzip sense the size of the file to add/extract and decide to
    71   //       use or not temporary file. The algorythm is looking for 
     71  //       use or not temporary file. The algorythm is looking for
    7272  //       memory_limit of PHP and apply a ratio.
    7373  //       threshold = memory_limit * ratio.
     
    153153  define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );
    154154  define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 ); // alias
    155  
     155
    156156  // ----- File description attributes
    157157  define( 'PCLZIP_ATT_FILE_NAME', 79001 );
     
    199199    var $error_code = 1;
    200200    var $error_string = '';
    201    
     201
    202202    // ----- Current status of the magic_quotes_runtime
    203203    // This value store the php configuration for magic_quotes
     
    333333      }
    334334    }
    335    
     335
    336336    // ----- Look for default option values
    337337    $this->privOptionDefaultThreshold($v_options);
     
    342342    $v_filedescr_list = array();
    343343    $p_result_list = array();
    344    
     344
    345345    // ----- Look if the $p_filelist is really an array
    346346    if (is_array($p_filelist)) {
    347    
     347
    348348      // ----- Look if the first element is also an array
    349349      //       This will mean that this is a file description entry
     
    351351        $v_att_list = $p_filelist;
    352352      }
    353      
     353
    354354      // ----- The list is a list of string names
    355355      else {
     
    369369      return 0;
    370370    }
    371    
     371
    372372    // ----- Reformat the string list
    373373    if (sizeof($v_string_list) != 0) {
     
    380380      }
    381381    }
    382    
     382
    383383    // ----- For each file in the list check the attributes
    384384    $v_supported_attributes
     
    529529    $v_filedescr_list = array();
    530530    $p_result_list = array();
    531    
     531
    532532    // ----- Look if the $p_filelist is really an array
    533533    if (is_array($p_filelist)) {
    534    
     534
    535535      // ----- Look if the first element is also an array
    536536      //       This will mean that this is a file description entry
     
    538538        $v_att_list = $p_filelist;
    539539      }
    540      
     540
    541541      // ----- The list is a list of string names
    542542      else {
     
    556556      return 0;
    557557    }
    558    
     558
    559559    // ----- Reformat the string list
    560560    if (sizeof($v_string_list) != 0) {
     
    563563      }
    564564    }
    565    
     565
    566566    // ----- For each file in the list check the attributes
    567567    $v_supported_attributes
     
    997997  //   PCLZIP_OPT_BY_INDEX :
    998998  //   PCLZIP_OPT_BY_NAME :
    999   //   PCLZIP_OPT_BY_EREG : 
     999  //   PCLZIP_OPT_BY_EREG :
    10001000  //   PCLZIP_OPT_BY_PREG :
    10011001  // Return Values :
     
    10651065  function deleteByIndex($p_index)
    10661066  {
    1067    
     1067
    10681068    $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
    10691069
     
    11151115      {
    11161116        $this->privSwapBackMagicQuotes();
    1117        
     1117
    11181118        // ----- Error log
    11191119        PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
     
    14271427  {
    14281428    $v_result=1;
    1429    
     1429
    14301430    // ----- Read the options
    14311431    $i=0;
     
    14671467            return PclZip::errorCode();
    14681468          }
    1469          
     1469
    14701470          // ----- Check for incompatible options
    14711471          if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
     
    14731473            return PclZip::errorCode();
    14741474          }
    1475          
     1475
    14761476          // ----- Check the value
    14771477          $v_value = $p_options_list[$i+1];
     
    14921492            return PclZip::errorCode();
    14931493          }
    1494          
     1494
    14951495          $v_result_list[$p_options_list[$i]] = true;
    14961496        break;
     
    15071507            return PclZip::errorCode();
    15081508          }
    1509          
     1509
    15101510          $v_result_list[$p_options_list[$i]] = true;
    15111511        break;
     
    16561656            return PclZip::errorCode();
    16571657          }
    1658          
     1658
    16591659          // ----- Reduce the index list
    16601660          // each index item in the list must be a couple with a start and
     
    16671667              $v_item_list = explode("-", $v_work_list[$j]);
    16681668              $v_size_item_list = sizeof($v_item_list);
    1669              
     1669
    16701670              // ----- TBC : Here we might check that each item is a
    16711671              // real integer ...
    1672              
     1672
    16731673              // ----- Look for single value
    16741674              if ($v_size_item_list == 1) {
     
    17041704              $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
    17051705          }
    1706          
     1706
    17071707          // ----- Sort the items
    17081708          if ($v_sort_flag) {
     
    18071807      }
    18081808    }
    1809    
     1809
    18101810    // ----- Look for default values
    18111811    if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
    1812      
     1812
    18131813    }
    18141814
     
    18271827  {
    18281828    $v_result=1;
    1829    
     1829
    18301830    if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
    18311831        || isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) {
    18321832      return $v_result;
    18331833    }
    1834    
     1834
    18351835    // ----- Get 'memory_limit' configuration value
    18361836    $v_memory_limit = ini_get('memory_limit');
    18371837    $v_memory_limit = trim($v_memory_limit);
    18381838    $last = strtolower(substr($v_memory_limit, -1));
    1839  
     1839
    18401840    if($last == 'g')
    18411841        //$v_memory_limit = $v_memory_limit*1024*1024*1024;
     
    18461846    if($last == 'k')
    18471847        $v_memory_limit = $v_memory_limit*1024;
    1848            
     1848
    18491849    $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO);
    1850    
     1850
    18511851
    18521852    // ----- Sanity check : No threshold if value lower than 1M
     
    18541854      unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
    18551855    }
    1856          
     1856
    18571857    // ----- Return
    18581858    return $v_result;
     
    18711871  {
    18721872    $v_result=1;
    1873    
     1873
    18741874    // ----- For each file in the list check the attributes
    18751875    foreach ($p_file_list as $v_key => $v_value) {
    1876    
     1876
    18771877      // ----- Check if the option is supported
    18781878      if (!isset($v_requested_options[$v_key])) {
     
    18931893
    18941894          $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
    1895          
     1895
    18961896          if ($p_filedescr['filename'] == '') {
    18971897            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
     
    19741974        }
    19751975      }
    1976    
     1976
    19771977    // end foreach
    19781978    }
    1979    
     1979
    19801980    // ----- Return
    19811981    return $v_result;
     
    19901990  //   just ignore the item.
    19911991  //   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 
     1992  //   When its a folder, expand the folder with all the files that are in that
    19931993  //   folder (recursively).
    19941994  // Parameters :
     
    20002000  {
    20012001    $v_result=1;
    2002    
     2002
    20032003    // ----- Create a result list
    20042004    $v_result_list = array();
    2005    
     2005
    20062006    // ----- Look each entry
    20072007    for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
    2008      
     2008
    20092009      // ----- Get filedescr
    20102010      $v_descr = $p_filedescr_list[$i];
    2011      
     2011
    20122012      // ----- Reduce the filename
    20132013      $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
    20142014      $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
    2015      
     2015
    20162016      // ----- Look for real file or folder
    20172017      if (file_exists($v_descr['filename'])) {
     
    20312031        }
    20322032      }
    2033      
     2033
    20342034      // ----- Look for string added as file
    20352035      else if (isset($v_descr['content'])) {
    20362036        $v_descr['type'] = 'virtual_file';
    20372037      }
    2038      
     2038
    20392039      // ----- Missing file
    20402040      else {
     
    20452045        return PclZip::errorCode();
    20462046      }
    2047      
     2047
    20482048      // ----- Calculate the stored filename
    20492049      $this->privCalculateStoredFilename($v_descr, $p_options);
    2050      
     2050
    20512051      // ----- Add the descriptor in result list
    20522052      $v_result_list[sizeof($v_result_list)] = $v_descr;
    2053      
     2053
    20542054      // ----- Look for folder
    20552055      if ($v_descr['type'] == 'folder') {
     
    20642064                continue;
    20652065            }
    2066            
     2066
    20672067            // ----- Compose the full filename
    20682068            $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
    2069            
     2069
    20702070            // ----- Look for different stored filename
    20712071            // Because the name of the folder was changed, the name of the
     
    20802080              }
    20812081            }
    2082      
     2082
    20832083            $v_dirlist_nb++;
    20842084          }
    2085          
     2085
    20862086          @closedir($v_folder_handler);
    20872087        }
     
    20892089          // TBC : unable to open folder in read mode
    20902090        }
    2091        
     2091
    20922092        // ----- Expand each element of the list
    20932093        if ($v_dirlist_nb != 0) {
     
    20962096            return $v_result;
    20972097          }
    2098          
     2098
    20992099          // ----- Concat the resulting list
    21002100          $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
     
    21022102        else {
    21032103        }
    2104          
     2104
    21052105        // ----- Free local array
    21062106        unset($v_dirlist_descr);
    21072107      }
    21082108    }
    2109    
     2109
    21102110    // ----- Get the result list
    21112111    $p_filedescr_list = $v_result_list;
     
    21262126    $v_result=1;
    21272127    $v_list_detail = array();
    2128    
     2128
    21292129    // ----- Magic quotes trick
    21302130    $this->privDisableMagicQuotes();
     
    24562456  // Description :
    24572457  // Parameters :
    2458   //   $p_filedescr_list : An array containing the file description 
     2458  //   $p_filedescr_list : An array containing the file description
    24592459  //                      or directory names to add in the zip
    24602460  //   $p_result_list : list of added files with their properties (specially the status field)
     
    24742474      $p_filedescr_list[$j]['filename']
    24752475      = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
    2476      
     2476
    24772477
    24782478      // ----- Skip empty file names
     
    25262526  {
    25272527    $v_result=1;
    2528    
     2528
    25292529    // ----- Working variable
    25302530    $p_filename = $p_filedescr['filename'];
     
    25382538      return PclZip::errorCode();
    25392539    }
    2540  
    2541     // ----- Look for a stored different filename 
     2540
     2541    // ----- Look for a stored different filename
    25422542    /* TBC : Removed
    25432543    if (isset($p_filedescr['stored_filename'])) {
     
    25742574      $p_header['size'] = filesize($p_filename);
    25752575    }
    2576    
     2576
    25772577    // ----- Look for regular folder
    25782578    else if ($p_filedescr['type']=='folder') {
     
    25812581      $p_header['size'] = filesize($p_filename);
    25822582    }
    2583    
     2583
    25842584    // ----- Look for virtual file
    25852585    else if ($p_filedescr['type'] == 'virtual_file') {
     
    25872587      $p_header['size'] = strlen($p_filedescr['content']);
    25882588    }
    2589    
     2589
    25902590
    25912591    // ----- Look for filetime
     
    26382638      $p_header['status'] = "filtered";
    26392639    }
    2640    
     2640
    26412641    // ----- Check the path length
    26422642    if (strlen($p_header['stored_filename']) > 0xFF) {
     
    26502650      if ($p_filedescr['type'] == 'file') {
    26512651        // ----- Look for using temporary file to zip
    2652         if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) 
     2652        if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
    26532653            && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
    26542654                || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     
    26592659          }
    26602660        }
    2661        
     2661
    26622662        // ----- Use "in memory" zip algo
    26632663        else {
     
    26772677        // ----- Calculate the CRC
    26782678        $p_header['crc'] = @crc32($v_content);
    2679        
     2679
    26802680        // ----- Look for no compression
    26812681        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
     
    26842684          $p_header['compression'] = 0;
    26852685        }
    2686        
     2686
    26872687        // ----- Look for normal compression
    26882688        else {
     
    26942694          $p_header['compression'] = 8;
    26952695        }
    2696        
     2696
    26972697        // ----- Call the header generation
    26982698        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     
    27102710      // ----- Look for a virtual file (a file from string)
    27112711      else if ($p_filedescr['type'] == 'virtual_file') {
    2712          
     2712
    27132713        $v_content = $p_filedescr['content'];
    27142714
    27152715        // ----- Calculate the CRC
    27162716        $p_header['crc'] = @crc32($v_content);
    2717        
     2717
    27182718        // ----- Look for no compression
    27192719        if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
     
    27222722          $p_header['compression'] = 0;
    27232723        }
    2724        
     2724
    27252725        // ----- Look for normal compression
    27262726        else {
     
    27322732          $p_header['compression'] = 8;
    27332733        }
    2734        
     2734
    27352735        // ----- Call the header generation
    27362736        if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
     
    27972797  {
    27982798    $v_result=PCLZIP_ERR_NO_ERROR;
    2799    
     2799
    28002800    // ----- Working variable
    28012801    $p_filename = $p_filedescr['filename'];
     
    28922892    // ----- Unlink the temporary file
    28932893    @unlink($v_gzip_temp_name);
    2894    
     2894
    28952895    // ----- Return
    28962896    return $v_result;
     
    29092909  {
    29102910    $v_result=1;
    2911    
     2911
    29122912    // ----- Working variables
    29132913    $p_filename = $p_filedescr['filename'];
     
    29372937      $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
    29382938    }
    2939    
     2939
    29402940    // ----- Look for path and/or short name change
    29412941    else {
     
    29672967        if (   (substr($p_filename, 0, 2) == "./")
    29682968            || (substr($p_remove_dir, 0, 2) == "./")) {
    2969            
     2969
    29702970          if (   (substr($p_filename, 0, 2) == "./")
    29712971              && (substr($p_remove_dir, 0, 2) != "./")) {
     
    29902990        }
    29912991      }
    2992      
     2992
    29932993      // ----- Remove drive letter if any
    29942994      $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
    2995      
     2995
    29962996      // ----- Look for path to add
    29972997      if ($p_add_dir != "") {
     
    30063006    $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
    30073007    $p_filedescr['stored_filename'] = $v_stored_filename;
    3008    
     3008
    30093009    // ----- Return
    30103010    return $v_result;
     
    31573157      // ----- Magic quotes trick
    31583158      $this->privSwapBackMagicQuotes();
    3159      
     3159
    31603160      // ----- Error log
    31613161      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
     
    33883388      // ----- Look for extract by ereg rule
    33893389      // ereg() is deprecated with PHP 5.3
    3390       /* 
     3390      /*
    33913391      else if (   (isset($p_options[PCLZIP_OPT_BY_EREG]))
    33923392               && ($p_options[PCLZIP_OPT_BY_EREG] != "")) {
     
    34103410      else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX]))
    34113411               && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
    3412          
     3412
    34133413          // ----- Look if the index is in the list
    34143414          for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) {
     
    34433443
    34443444              $this->privSwapBackMagicQuotes();
    3445              
     3445
    34463446              PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_COMPRESSION,
    34473447                                   "Filename '".$v_header['stored_filename']."' is "
     
    34523452          }
    34533453      }
    3454      
     3454
    34553455      // ----- Check encrypted files
    34563456      if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
     
    34843484          $v_extract = false;
    34853485      }
    3486      
     3486
    34873487      // ----- Look for real extraction
    34883488      if ($v_extract)
     
    35333533          // ----- Next extracted file
    35343534          $v_nb_extracted++;
    3535          
     3535
    35363536          // ----- Look for user callback abort
    35373537          if ($v_result1 == 2) {
     
    36693669      $p_entry['filename'] = $p_path."/".$p_entry['filename'];
    36703670    }
    3671    
     3671
    36723672    // ----- Check a base_dir_restriction
    36733673    if (isset($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION])) {
    36743674      $v_inclusion
    36753675      = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION],
    3676                                 $p_entry['filename']); 
     3676                                $p_entry['filename']);
    36773677      if ($v_inclusion == 0) {
    36783678
     
    37013701        $v_result = 1;
    37023702      }
    3703      
     3703
    37043704      // ----- Look for abort result
    37053705      if ($v_result == 2) {
     
    37283728        // ----- Change the file status
    37293729        $p_entry['status'] = "already_a_directory";
    3730        
     3730
    37313731        // ----- Look for PCLZIP_OPT_STOP_ON_ERROR
    37323732        // For historical reason first PclZip implementation does not stop
     
    38013801
    38023802        if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) {
    3803  
     3803
    38043804          // ----- Change the file status
    38053805          $p_entry['status'] = "path_creation_fail";
    3806  
     3806
    38073807          // ----- Return
    38083808          //return $v_result;
     
    38433843            @fwrite($v_dest_file, $v_binary_data, $v_read_size);
    38443844            */
    3845             @fwrite($v_dest_file, $v_buffer, $v_read_size);           
     3845            @fwrite($v_dest_file, $v_buffer, $v_read_size);
    38463846            $v_size -= $v_read_size;
    38473847          }
     
    38523852          // ----- Change the file mtime
    38533853          touch($p_entry['filename'], $p_entry['mtime']);
    3854          
     3854
    38553855
    38563856        }
     
    38653865
    38663866          // ----- Look for using temporary file to unzip
    3867           if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) 
     3867          if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF]))
    38683868              && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
    38693869                  || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
     
    38743874            }
    38753875          }
    3876          
     3876
    38773877          // ----- Look for extract in memory
    38783878          else {
    38793879
    3880          
     3880
    38813881            // ----- Read the compressed file in a buffer (one shot)
    38823882            $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
    3883            
     3883
    38843884            // ----- Decompress the file
    38853885            $v_file_content = @gzinflate($v_buffer);
    38863886            unset($v_buffer);
    38873887            if ($v_file_content === FALSE) {
    3888  
     3888
    38893889              // ----- Change the file status
    38903890              // TBC
    38913891              $p_entry['status'] = "error";
    3892              
     3892
    38933893              return $v_result;
    38943894            }
    3895            
     3895
    38963896            // ----- Opening destination file
    38973897            if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
    3898  
     3898
    38993899              // ----- Change the file status
    39003900              $p_entry['status'] = "write_error";
    3901  
     3901
    39023902              return $v_result;
    39033903            }
    3904  
     3904
    39053905            // ----- Write the uncompressed data
    39063906            @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
    39073907            unset($v_file_content);
    3908  
     3908
    39093909            // ----- Closing the destination file
    39103910            @fclose($v_dest_file);
    3911            
     3911
    39123912          }
    39133913
     
    39303930        $p_entry['status'] = "skipped";
    39313931    }
    3932    
     3932
    39333933    // ----- Look for post-extract callback
    39343934    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
     
    39633963  {
    39643964    $v_result=1;
    3965        
     3965
    39663966    // ----- Creates a temporary file
    39673967    $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
     
    40244024    // ----- Delete the temporary file
    40254025    @unlink($v_gzip_temp_name);
    4026    
     4026
    40274027    // ----- Return
    40284028    return $v_result;
     
    41024102          // ----- Read the compressed file in a buffer (one shot)
    41034103          $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
    4104          
     4104
    41054105          // ----- Decompress the file
    41064106          $v_file_content = gzinflate($v_buffer);
     
    41814181        $v_result = 1;
    41824182      }
    4183      
     4183
    41844184      // ----- Look for abort result
    41854185      if ($v_result == 2) {
     
    42034203  //      if ($p_entry['compressed_size'] == $p_entry['size'])
    42044204        if ($p_entry['compression'] == 0) {
    4205  
     4205
    42064206          // ----- Reading the file
    42074207          $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
    42084208        }
    42094209        else {
    4210  
     4210
    42114211          // ----- Reading the file
    42124212          $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
    4213          
     4213
    42144214          // ----- Decompress the file
    42154215          if (($p_string = @gzinflate($v_data)) === FALSE) {
     
    42174217          }
    42184218        }
    4219  
     4219
    42204220        // ----- Trace
    42214221      }
     
    42234223          // TBC : error : can not extract a folder in a string
    42244224      }
    4225      
     4225
    42264226    }
    42274227
     
    42304230        $p_entry['status'] = "skipped";
    42314231    }
    4232    
     4232
    42334233    // ----- Look for post-extract callback
    42344234    elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
     
    42374237      $v_local_header = array();
    42384238      $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
    4239      
     4239
    42404240      // ----- Swap the content to header
    42414241      $v_local_header['content'] = $p_string;
     
    44974497    if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
    44984498    }
    4499  
     4499
    45004500    // ----- Look for flag bit 3
    45014501    if (($p_local_header['flag'] & 8) == 8) {
     
    45834583        // -----  Add the byte
    45844584        //$v_bytes = ($v_bytes << 8) | Ord($v_byte);
    4585         // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number 
    4586         // Otherwise on systems where we have 64bit integers the check below for the magic number will fail. 
    4587         $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte); 
     4585        // Note we mask the old value down such that once shifted we can never end up with more than a 32bit number
     4586        // Otherwise on systems where we have 64bit integers the check below for the magic number will fail.
     4587        $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte);
    45884588
    45894589        // ----- Compare the bytes
     
    48634863                return $v_result;
    48644864            }
    4865            
     4865
    48664866            // ----- Check that local file header is same as central file header
    48674867            if ($this->privCheckFileHeaders($v_local_header,
     
    49474947        //@rename($v_zip_temp_name, $this->zipname);
    49484948        PclZipUtilRename($v_zip_temp_name, $this->zipname);
    4949    
     4949
    49504950        // ----- Destroy the temporary archive
    49514951        unset($v_temp_zip);
    49524952    }
    4953    
     4953
    49544954    // ----- Remove every files : reset the file
    49554955    else if ($v_central_dir['entries'] != 0) {
     
    54385438        }
    54395439      }
    5440      
     5440
    54415441      // ----- Look for skip
    54425442      if ($v_skip > 0) {
     
    54715471  {
    54725472    $v_result = 1;
    5473    
     5473
    54745474    // ----- Look for path beginning by ./
    54755475    if (   ($p_dir == '.')
     
    56395639  function PclZipUtilOptionText($p_option)
    56405640  {
    5641    
     5641
    56425642    $v_list = get_defined_constants();
    56435643    for (reset($v_list); $v_key = key($v_list); next($v_list)) {
     
    56505650        }
    56515651    }
    5652    
     5652
    56535653    $v_result = 'Unknown';
    56545654
Note: See TracChangeset for help on using the changeset viewer.