Просмотр файла system/inc/classes/pclzip.class.php

Конкурс дизайнеров на 15000 рублей
Скрипты | CMS | Боты
Размер файла: 123.06Kb 
  1. <?php
  2.  
  3.   if (!defined('PCLZIP_READ_BLOCK_SIZE')) {define( 'PCLZIP_READ_BLOCK_SIZE', 2048 );}
  4.   if (!defined('PCLZIP_SEPARATOR')) {define( 'PCLZIP_SEPARATOR', ',' );}
  5.   if (!defined('PCLZIP_ERROR_EXTERNAL')) {define( 'PCLZIP_ERROR_EXTERNAL', 0 );}
  6.   if (!defined('PCLZIP_TEMPORARY_DIR')) {define( 'PCLZIP_TEMPORARY_DIR', '' );}
  7.   if (!defined('PCLZIP_TEMPORARY_FILE_RATIO')) {define( 'PCLZIP_TEMPORARY_FILE_RATIO', 0.47 );}
  8.  
  9.   $g_pclzip_version = "2.8.2";
  10.  
  11.   define( 'PCLZIP_ERR_USER_ABORTED', 2 );
  12.   define( 'PCLZIP_ERR_NO_ERROR', 0 );
  13.   define( 'PCLZIP_ERR_WRITE_OPEN_FAIL', -1 );
  14.   define( 'PCLZIP_ERR_READ_OPEN_FAIL', -2 );
  15.   define( 'PCLZIP_ERR_INVALID_PARAMETER', -3 );
  16.   define( 'PCLZIP_ERR_MISSING_FILE', -4 );
  17.   define( 'PCLZIP_ERR_FILENAME_TOO_LONG', -5 );
  18.   define( 'PCLZIP_ERR_INVALID_ZIP', -6 );
  19.   define( 'PCLZIP_ERR_BAD_EXTRACTED_FILE', -7 );
  20.   define( 'PCLZIP_ERR_DIR_CREATE_FAIL', -8 );
  21.   define( 'PCLZIP_ERR_BAD_EXTENSION', -9 );
  22.   define( 'PCLZIP_ERR_BAD_FORMAT', -10 );
  23.   define( 'PCLZIP_ERR_DELETE_FILE_FAIL', -11 );
  24.   define( 'PCLZIP_ERR_RENAME_FILE_FAIL', -12 );
  25.   define( 'PCLZIP_ERR_BAD_CHECKSUM', -13 );
  26.   define( 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP', -14 );
  27.   define( 'PCLZIP_ERR_MISSING_OPTION_VALUE', -15 );
  28.   define( 'PCLZIP_ERR_INVALID_OPTION_VALUE', -16 );
  29.   define( 'PCLZIP_ERR_ALREADY_A_DIRECTORY', -17 );
  30.   define( 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION', -18 );
  31.   define( 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION', -19 );
  32.   define( 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE', -20 );
  33.   define( 'PCLZIP_ERR_DIRECTORY_RESTRICTION', -21 );
  34.  
  35.   define( 'PCLZIP_OPT_PATH', 77001 );
  36.   define( 'PCLZIP_OPT_ADD_PATH', 77002 );
  37.   define( 'PCLZIP_OPT_REMOVE_PATH', 77003 );
  38.   define( 'PCLZIP_OPT_REMOVE_ALL_PATH', 77004 );
  39.   define( 'PCLZIP_OPT_SET_CHMOD', 77005 );
  40.   define( 'PCLZIP_OPT_EXTRACT_AS_STRING', 77006 );
  41.   define( 'PCLZIP_OPT_NO_COMPRESSION', 77007 );
  42.   define( 'PCLZIP_OPT_BY_NAME', 77008 );
  43.   define( 'PCLZIP_OPT_BY_INDEX', 77009 );
  44.   define( 'PCLZIP_OPT_BY_EREG', 77010 );
  45.   define( 'PCLZIP_OPT_BY_PREG', 77011 );
  46.   define( 'PCLZIP_OPT_COMMENT', 77012 );
  47.   define( 'PCLZIP_OPT_ADD_COMMENT', 77013 );
  48.   define( 'PCLZIP_OPT_PREPEND_COMMENT', 77014 );
  49.   define( 'PCLZIP_OPT_EXTRACT_IN_OUTPUT', 77015 );
  50.   define( 'PCLZIP_OPT_REPLACE_NEWER', 77016 );
  51.   define( 'PCLZIP_OPT_STOP_ON_ERROR', 77017 );
  52.   define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );
  53.   define( 'PCLZIP_OPT_TEMP_FILE_THRESHOLD', 77020 );
  54.   define( 'PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD', 77020 );   define( 'PCLZIP_OPT_TEMP_FILE_ON', 77021 );
  55.   define( 'PCLZIP_OPT_ADD_TEMP_FILE_ON', 77021 );   define( 'PCLZIP_OPT_TEMP_FILE_OFF', 77022 );
  56.   define( 'PCLZIP_OPT_ADD_TEMP_FILE_OFF', 77022 );   
  57.   define( 'PCLZIP_ATT_FILE_NAME', 79001 );
  58.   define( 'PCLZIP_ATT_FILE_NEW_SHORT_NAME', 79002 );
  59.   define( 'PCLZIP_ATT_FILE_NEW_FULL_NAME', 79003 );
  60.   define( 'PCLZIP_ATT_FILE_MTIME', 79004 );
  61.   define( 'PCLZIP_ATT_FILE_CONTENT', 79005 );
  62.   define( 'PCLZIP_ATT_FILE_COMMENT', 79006 );
  63.  
  64.   define( 'PCLZIP_CB_PRE_EXTRACT', 78001 );
  65.   define( 'PCLZIP_CB_POST_EXTRACT', 78002 );
  66.   define( 'PCLZIP_CB_PRE_ADD', 78003 );
  67.   define( 'PCLZIP_CB_POST_ADD', 78004 );
  68.  
  69.  class PclZip {
  70.         var $zipname = '';
  71.         var $zip_fd = 0;
  72.         var $error_code = 1;
  73.         var $error_string = '';
  74.         var $magic_quotes_status;
  75.  
  76.                   function PclZip($p_zipname)
  77.   {
  78.  
  79.         if (!function_exists('gzopen'))
  80.     {
  81.       die('Abort '.basename(__FILE__).' : Missing zlib extensions');
  82.     }
  83.  
  84.         $this->zipname = $p_zipname;
  85.     $this->zip_fd = 0;
  86.     $this->magic_quotes_status = -1;
  87.  
  88.         return;
  89.   }
  90.   
  91.                                                                             function create($p_filelist)
  92.   {
  93.     $v_result=1;
  94.  
  95.         $this->privErrorReset();
  96.  
  97.         $v_options = array();
  98.     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
  99.  
  100.         $v_size = func_num_args();
  101.  
  102.         if ($v_size > 1) {
  103.             $v_arg_list = func_get_args();
  104.  
  105.             array_shift($v_arg_list);
  106.       $v_size--;
  107.  
  108.             if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
  109.  
  110.                 $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
  111.                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',
  112.                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
  113.                                                    PCLZIP_OPT_ADD_PATH => 'optional',
  114.                                                    PCLZIP_CB_PRE_ADD => 'optional',
  115.                                                    PCLZIP_CB_POST_ADD => 'optional',
  116.                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',
  117.                                                    PCLZIP_OPT_COMMENT => 'optional',
  118.                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
  119.                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
  120.                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
  121.                                                                                                 ));
  122.         if ($v_result != 1) {
  123.           return 0;
  124.         }
  125.       }
  126.  
  127.                         else {
  128.  
  129.                 $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];
  130.  
  131.                 if ($v_size == 2) {
  132.           $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
  133.         }
  134.         else if ($v_size > 2) {
  135.           PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
  136. 		                       "Invalid number / type of arguments");
  137.           return 0;
  138.         }
  139.       }
  140.     }
  141.     
  142.         $this->privOptionDefaultThreshold($v_options);
  143.  
  144.         $v_string_list = array();
  145.     $v_att_list = array();
  146.     $v_filedescr_list = array();
  147.     $p_result_list = array();
  148.     
  149.         if (is_array($p_filelist)) {
  150.     
  151.                   if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
  152.         $v_att_list = $p_filelist;
  153.       }
  154.       
  155.             else {
  156.         $v_string_list = $p_filelist;
  157.       }
  158.     }
  159.  
  160.         else if (is_string($p_filelist)) {
  161.             $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
  162.     }
  163.  
  164.         else {
  165.       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");
  166.       return 0;
  167.     }
  168.     
  169.         if (sizeof($v_string_list) != 0) {
  170.       foreach ($v_string_list as $v_string) {
  171.         if ($v_string != '') {
  172.           $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
  173.         }
  174.         else {
  175.         }
  176.       }
  177.     }
  178.     
  179.         $v_supported_attributes
  180.     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
  181.              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
  182.              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
  183.              ,PCLZIP_ATT_FILE_MTIME => 'optional'
  184.              ,PCLZIP_ATT_FILE_CONTENT => 'optional'
  185.              ,PCLZIP_ATT_FILE_COMMENT => 'optional'
  186. 						);
  187.     foreach ($v_att_list as $v_entry) {
  188.       $v_result = $this->privFileDescrParseAtt($v_entry,
  189.                                                $v_filedescr_list[],
  190.                                                $v_options,
  191.                                                $v_supported_attributes);
  192.       if ($v_result != 1) {
  193.         return 0;
  194.       }
  195.     }
  196.  
  197.         $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
  198.     if ($v_result != 1) {
  199.       return 0;
  200.     }
  201.  
  202.         $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);
  203.     if ($v_result != 1) {
  204.       return 0;
  205.     }
  206.  
  207.         return $p_result_list;
  208.   }
  209.   
  210.                                                                         function add($p_filelist)
  211.   {
  212.     $v_result=1;
  213.  
  214.         $this->privErrorReset();
  215.  
  216.         $v_options = array();
  217.     $v_options[PCLZIP_OPT_NO_COMPRESSION] = FALSE;
  218.  
  219.         $v_size = func_num_args();
  220.  
  221.         if ($v_size > 1) {
  222.             $v_arg_list = func_get_args();
  223.  
  224.             array_shift($v_arg_list);
  225.       $v_size--;
  226.  
  227.             if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
  228.  
  229.                 $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
  230.                                             array (PCLZIP_OPT_REMOVE_PATH => 'optional',
  231.                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
  232.                                                    PCLZIP_OPT_ADD_PATH => 'optional',
  233.                                                    PCLZIP_CB_PRE_ADD => 'optional',
  234.                                                    PCLZIP_CB_POST_ADD => 'optional',
  235.                                                    PCLZIP_OPT_NO_COMPRESSION => 'optional',
  236.                                                    PCLZIP_OPT_COMMENT => 'optional',
  237.                                                    PCLZIP_OPT_ADD_COMMENT => 'optional',
  238.                                                    PCLZIP_OPT_PREPEND_COMMENT => 'optional',
  239.                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
  240.                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
  241.                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
  242.                                                    												   ));
  243.         if ($v_result != 1) {
  244.           return 0;
  245.         }
  246.       }
  247.  
  248.                         else {
  249.  
  250.                 $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];
  251.  
  252.                 if ($v_size == 2) {
  253.           $v_options[PCLZIP_OPT_REMOVE_PATH] = $v_arg_list[1];
  254.         }
  255.         else if ($v_size > 2) {
  256.                     PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
  257.  
  258.                     return 0;
  259.         }
  260.       }
  261.     }
  262.  
  263.         $this->privOptionDefaultThreshold($v_options);
  264.  
  265.         $v_string_list = array();
  266.     $v_att_list = array();
  267.     $v_filedescr_list = array();
  268.     $p_result_list = array();
  269.     
  270.         if (is_array($p_filelist)) {
  271.     
  272.                   if (isset($p_filelist[0]) && is_array($p_filelist[0])) {
  273.         $v_att_list = $p_filelist;
  274.       }
  275.       
  276.             else {
  277.         $v_string_list = $p_filelist;
  278.       }
  279.     }
  280.  
  281.         else if (is_string($p_filelist)) {
  282.             $v_string_list = explode(PCLZIP_SEPARATOR, $p_filelist);
  283.     }
  284.  
  285.         else {
  286.       PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");
  287.       return 0;
  288.     }
  289.     
  290.         if (sizeof($v_string_list) != 0) {
  291.       foreach ($v_string_list as $v_string) {
  292.         $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;
  293.       }
  294.     }
  295.     
  296.         $v_supported_attributes
  297.     = array ( PCLZIP_ATT_FILE_NAME => 'mandatory'
  298.              ,PCLZIP_ATT_FILE_NEW_SHORT_NAME => 'optional'
  299.              ,PCLZIP_ATT_FILE_NEW_FULL_NAME => 'optional'
  300.              ,PCLZIP_ATT_FILE_MTIME => 'optional'
  301.              ,PCLZIP_ATT_FILE_CONTENT => 'optional'
  302.              ,PCLZIP_ATT_FILE_COMMENT => 'optional'
  303. 						);
  304.     foreach ($v_att_list as $v_entry) {
  305.       $v_result = $this->privFileDescrParseAtt($v_entry,
  306.                                                $v_filedescr_list[],
  307.                                                $v_options,
  308.                                                $v_supported_attributes);
  309.       if ($v_result != 1) {
  310.         return 0;
  311.       }
  312.     }
  313.  
  314.         $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);
  315.     if ($v_result != 1) {
  316.       return 0;
  317.     }
  318.  
  319.         $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);
  320.     if ($v_result != 1) {
  321.       return 0;
  322.     }
  323.  
  324.         return $p_result_list;
  325.   }
  326.   
  327.                                                                                     function listContent()
  328.   {
  329.     $v_result=1;
  330.  
  331.         $this->privErrorReset();
  332.  
  333.         if (!$this->privCheckFormat()) {
  334.       return(0);
  335.     }
  336.  
  337.         $p_list = array();
  338.     if (($v_result = $this->privList($p_list)) != 1)
  339.     {
  340.       unset($p_list);
  341.       return(0);
  342.     }
  343.  
  344.         return $p_list;
  345.   }
  346.   
  347.                                                                   function extract()
  348.   {
  349.     $v_result=1;
  350.  
  351.         $this->privErrorReset();
  352.  
  353.         if (!$this->privCheckFormat()) {
  354.       return(0);
  355.     }
  356.  
  357.         $v_options = array();
  358.     $v_path = '';
  359.     $v_remove_path = "";
  360.     $v_remove_all_path = false;
  361.  
  362.         $v_size = func_num_args();
  363.  
  364.         $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
  365.  
  366.         if ($v_size > 0) {
  367.             $v_arg_list = func_get_args();
  368.  
  369.             if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
  370.  
  371.                 $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
  372.                                             array (PCLZIP_OPT_PATH => 'optional',
  373.                                                    PCLZIP_OPT_REMOVE_PATH => 'optional',
  374.                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
  375.                                                    PCLZIP_OPT_ADD_PATH => 'optional',
  376.                                                    PCLZIP_CB_PRE_EXTRACT => 'optional',
  377.                                                    PCLZIP_CB_POST_EXTRACT => 'optional',
  378.                                                    PCLZIP_OPT_SET_CHMOD => 'optional',
  379.                                                    PCLZIP_OPT_BY_NAME => 'optional',
  380.                                                    PCLZIP_OPT_BY_EREG => 'optional',
  381.                                                    PCLZIP_OPT_BY_PREG => 'optional',
  382.                                                    PCLZIP_OPT_BY_INDEX => 'optional',
  383.                                                    PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
  384.                                                    PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',
  385.                                                    PCLZIP_OPT_REPLACE_NEWER => 'optional'
  386.                                                    ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
  387.                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
  388.                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
  389.                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
  390.                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
  391. 												    ));
  392.         if ($v_result != 1) {
  393.           return 0;
  394.         }
  395.  
  396.                 if (isset($v_options[PCLZIP_OPT_PATH])) {
  397.           $v_path = $v_options[PCLZIP_OPT_PATH];
  398.         }
  399.         if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
  400.           $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
  401.         }
  402.         if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
  403.           $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
  404.         }
  405.         if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
  406.                     if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
  407.             $v_path .= '/';
  408.           }
  409.           $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
  410.         }
  411.       }
  412.  
  413.                         else {
  414.  
  415.                 $v_path = $v_arg_list[0];
  416.  
  417.                 if ($v_size == 2) {
  418.           $v_remove_path = $v_arg_list[1];
  419.         }
  420.         else if ($v_size > 2) {
  421.                     PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
  422.  
  423.                     return 0;
  424.         }
  425.       }
  426.     }
  427.  
  428.         $this->privOptionDefaultThreshold($v_options);
  429.  
  430.     
  431.         $p_list = array();
  432.     $v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path,
  433. 	                                     $v_remove_all_path, $v_options);
  434.     if ($v_result < 1) {
  435.       unset($p_list);
  436.       return(0);
  437.     }
  438.  
  439.         return $p_list;
  440.   }
  441.   
  442.  
  443.                                                                             function extractByIndex($p_index)
  444.   {
  445.     $v_result=1;
  446.  
  447.         $this->privErrorReset();
  448.  
  449.         if (!$this->privCheckFormat()) {
  450.       return(0);
  451.     }
  452.  
  453.         $v_options = array();
  454.     $v_path = '';
  455.     $v_remove_path = "";
  456.     $v_remove_all_path = false;
  457.  
  458.         $v_size = func_num_args();
  459.  
  460.         $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
  461.  
  462.         if ($v_size > 1) {
  463.             $v_arg_list = func_get_args();
  464.  
  465.             array_shift($v_arg_list);
  466.       $v_size--;
  467.  
  468.             if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {
  469.  
  470.                 $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
  471.                                             array (PCLZIP_OPT_PATH => 'optional',
  472.                                                    PCLZIP_OPT_REMOVE_PATH => 'optional',
  473.                                                    PCLZIP_OPT_REMOVE_ALL_PATH => 'optional',
  474.                                                    PCLZIP_OPT_EXTRACT_AS_STRING => 'optional',
  475.                                                    PCLZIP_OPT_ADD_PATH => 'optional',
  476.                                                    PCLZIP_CB_PRE_EXTRACT => 'optional',
  477.                                                    PCLZIP_CB_POST_EXTRACT => 'optional',
  478.                                                    PCLZIP_OPT_SET_CHMOD => 'optional',
  479.                                                    PCLZIP_OPT_REPLACE_NEWER => 'optional'
  480.                                                    ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'
  481.                                                    ,PCLZIP_OPT_EXTRACT_DIR_RESTRICTION => 'optional',
  482.                                                    PCLZIP_OPT_TEMP_FILE_THRESHOLD => 'optional',
  483.                                                    PCLZIP_OPT_TEMP_FILE_ON => 'optional',
  484.                                                    PCLZIP_OPT_TEMP_FILE_OFF => 'optional'
  485. 												   ));
  486.         if ($v_result != 1) {
  487.           return 0;
  488.         }
  489.  
  490.                 if (isset($v_options[PCLZIP_OPT_PATH])) {
  491.           $v_path = $v_options[PCLZIP_OPT_PATH];
  492.         }
  493.         if (isset($v_options[PCLZIP_OPT_REMOVE_PATH])) {
  494.           $v_remove_path = $v_options[PCLZIP_OPT_REMOVE_PATH];
  495.         }
  496.         if (isset($v_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
  497.           $v_remove_all_path = $v_options[PCLZIP_OPT_REMOVE_ALL_PATH];
  498.         }
  499.         if (isset($v_options[PCLZIP_OPT_ADD_PATH])) {
  500.                     if ((strlen($v_path) > 0) && (substr($v_path, -1) != '/')) {
  501.             $v_path .= '/';
  502.           }
  503.           $v_path .= $v_options[PCLZIP_OPT_ADD_PATH];
  504.         }
  505.         if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {
  506.           $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;
  507.         }
  508.         else {
  509.         }
  510.       }
  511.  
  512.                         else {
  513.  
  514.                 $v_path = $v_arg_list[0];
  515.  
  516.                 if ($v_size == 2) {
  517.           $v_remove_path = $v_arg_list[1];
  518.         }
  519.         else if ($v_size > 2) {
  520.                     PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");
  521.  
  522.                     return 0;
  523.         }
  524.       }
  525.     }
  526.  
  527.     
  528.                 $v_arg_trick = array (PCLZIP_OPT_BY_INDEX, $p_index);
  529.     $v_options_trick = array();
  530.     $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,
  531.                                         array (PCLZIP_OPT_BY_INDEX => 'optional' ));
  532.     if ($v_result != 1) {
  533.         return 0;
  534.     }
  535.     $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];
  536.  
  537.         $this->privOptionDefaultThreshold($v_options);
  538.  
  539.         if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {
  540.         return(0);
  541.     }
  542.  
  543.         return $p_list;
  544.   }
  545.   
  546.                                       function delete()
  547.   {
  548.     $v_result=1;
  549.  
  550.         $this->privErrorReset();
  551.  
  552.         if (!$this->privCheckFormat()) {
  553.       return(0);
  554.     }
  555.  
  556.         $v_options = array();
  557.  
  558.         $v_size = func_num_args();
  559.  
  560.         if ($v_size > 0) {
  561.             $v_arg_list = func_get_args();
  562.  
  563.             $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,
  564.                                         array (PCLZIP_OPT_BY_NAME => 'optional',
  565.                                                PCLZIP_OPT_BY_EREG => 'optional',
  566.                                                PCLZIP_OPT_BY_PREG => 'optional',
  567.                                                PCLZIP_OPT_BY_INDEX => 'optional' ));
  568.       if ($v_result != 1) {
  569.           return 0;
  570.       }
  571.     }
  572.  
  573.         $this->privDisableMagicQuotes();
  574.  
  575.         $v_list = array();
  576.     if (($v_result = $this->privDeleteByRule($v_list, $v_options)) != 1) {
  577.       $this->privSwapBackMagicQuotes();
  578.       unset($v_list);
  579.       return(0);
  580.     }
  581.  
  582.         $this->privSwapBackMagicQuotes();
  583.  
  584.         return $v_list;
  585.   }
  586.   
  587.               function deleteByIndex($p_index)
  588.   {
  589.     
  590.     $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);
  591.  
  592.         return $p_list;
  593.   }
  594.   
  595.                               function properties()
  596.   {
  597.  
  598.         $this->privErrorReset();
  599.  
  600.         $this->privDisableMagicQuotes();
  601.  
  602.         if (!$this->privCheckFormat()) {
  603.       $this->privSwapBackMagicQuotes();
  604.       return(0);
  605.     }
  606.  
  607.         $v_prop = array();
  608.     $v_prop['comment'] = '';
  609.     $v_prop['nb'] = 0;
  610.     $v_prop['status'] = 'not_exist';
  611.  
  612.         if (@is_file($this->zipname))
  613.     {
  614.             if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
  615.       {
  616.         $this->privSwapBackMagicQuotes();
  617.         
  618.                 PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
  619.  
  620.                 return 0;
  621.       }
  622.  
  623.             $v_central_dir = array();
  624.       if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
  625.       {
  626.         $this->privSwapBackMagicQuotes();
  627.         return 0;
  628.       }
  629.  
  630.             $this->privCloseFd();
  631.  
  632.             $v_prop['comment'] = $v_central_dir['comment'];
  633.       $v_prop['nb'] = $v_central_dir['entries'];
  634.       $v_prop['status'] = 'ok';
  635.     }
  636.  
  637.         $this->privSwapBackMagicQuotes();
  638.  
  639.         return $v_prop;
  640.   }
  641.   
  642.                           function duplicate($p_archive)
  643.   {
  644.     $v_result = 1;
  645.  
  646.         $this->privErrorReset();
  647.  
  648.         if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))
  649.     {
  650.  
  651.             $v_result = $this->privDuplicate($p_archive->zipname);
  652.     }
  653.  
  654.         else if (is_string($p_archive))
  655.     {
  656.  
  657.                   if (!is_file($p_archive)) {
  658.                 PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "No file with filename '".$p_archive."'");
  659.         $v_result = PCLZIP_ERR_MISSING_FILE;
  660.       }
  661.       else {
  662.                 $v_result = $this->privDuplicate($p_archive);
  663.       }
  664.     }
  665.  
  666.         else
  667.     {
  668.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
  669.       $v_result = PCLZIP_ERR_INVALID_PARAMETER;
  670.     }
  671.  
  672.         return $v_result;
  673.   }
  674.   
  675.                               function merge($p_archive_to_add)
  676.   {
  677.     $v_result = 1;
  678.  
  679.         $this->privErrorReset();
  680.  
  681.         if (!$this->privCheckFormat()) {
  682.       return(0);
  683.     }
  684.  
  685.         if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))
  686.     {
  687.  
  688.             $v_result = $this->privMerge($p_archive_to_add);
  689.     }
  690.  
  691.         else if (is_string($p_archive_to_add))
  692.     {
  693.  
  694.             $v_object_archive = new PclZip($p_archive_to_add);
  695.  
  696.             $v_result = $this->privMerge($v_object_archive);
  697.     }
  698.  
  699.         else
  700.     {
  701.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_archive_to_add");
  702.       $v_result = PCLZIP_ERR_INVALID_PARAMETER;
  703.     }
  704.  
  705.         return $v_result;
  706.   }
  707.   
  708.  
  709.  
  710.             function errorCode()
  711.   {
  712.     if (PCLZIP_ERROR_EXTERNAL == 1) {
  713.       return(PclErrorCode());
  714.     }
  715.     else {
  716.       return($this->error_code);
  717.     }
  718.   }
  719.   
  720.             function errorName($p_with_code=false)
  721.   {
  722.     $v_name = array ( PCLZIP_ERR_NO_ERROR => 'PCLZIP_ERR_NO_ERROR',
  723.                       PCLZIP_ERR_WRITE_OPEN_FAIL => 'PCLZIP_ERR_WRITE_OPEN_FAIL',
  724.                       PCLZIP_ERR_READ_OPEN_FAIL => 'PCLZIP_ERR_READ_OPEN_FAIL',
  725.                       PCLZIP_ERR_INVALID_PARAMETER => 'PCLZIP_ERR_INVALID_PARAMETER',
  726.                       PCLZIP_ERR_MISSING_FILE => 'PCLZIP_ERR_MISSING_FILE',
  727.                       PCLZIP_ERR_FILENAME_TOO_LONG => 'PCLZIP_ERR_FILENAME_TOO_LONG',
  728.                       PCLZIP_ERR_INVALID_ZIP => 'PCLZIP_ERR_INVALID_ZIP',
  729.                       PCLZIP_ERR_BAD_EXTRACTED_FILE => 'PCLZIP_ERR_BAD_EXTRACTED_FILE',
  730.                       PCLZIP_ERR_DIR_CREATE_FAIL => 'PCLZIP_ERR_DIR_CREATE_FAIL',
  731.                       PCLZIP_ERR_BAD_EXTENSION => 'PCLZIP_ERR_BAD_EXTENSION',
  732.                       PCLZIP_ERR_BAD_FORMAT => 'PCLZIP_ERR_BAD_FORMAT',
  733.                       PCLZIP_ERR_DELETE_FILE_FAIL => 'PCLZIP_ERR_DELETE_FILE_FAIL',
  734.                       PCLZIP_ERR_RENAME_FILE_FAIL => 'PCLZIP_ERR_RENAME_FILE_FAIL',
  735.                       PCLZIP_ERR_BAD_CHECKSUM => 'PCLZIP_ERR_BAD_CHECKSUM',
  736.                       PCLZIP_ERR_INVALID_ARCHIVE_ZIP => 'PCLZIP_ERR_INVALID_ARCHIVE_ZIP',
  737.                       PCLZIP_ERR_MISSING_OPTION_VALUE => 'PCLZIP_ERR_MISSING_OPTION_VALUE',
  738.                       PCLZIP_ERR_INVALID_OPTION_VALUE => 'PCLZIP_ERR_INVALID_OPTION_VALUE',
  739.                       PCLZIP_ERR_UNSUPPORTED_COMPRESSION => 'PCLZIP_ERR_UNSUPPORTED_COMPRESSION',
  740.                       PCLZIP_ERR_UNSUPPORTED_ENCRYPTION => 'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION'
  741.                       ,PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE => 'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE'
  742.                       ,PCLZIP_ERR_DIRECTORY_RESTRICTION => 'PCLZIP_ERR_DIRECTORY_RESTRICTION'
  743.                     );
  744.  
  745.     if (isset($v_name[$this->error_code])) {
  746.       $v_value = $v_name[$this->error_code];
  747.     }
  748.     else {
  749.       $v_value = 'NoName';
  750.     }
  751.  
  752.     if ($p_with_code) {
  753.       return($v_value.' ('.$this->error_code.')');
  754.     }
  755.     else {
  756.       return($v_value);
  757.     }
  758.   }
  759.   
  760.             function errorInfo($p_full=false)
  761.   {
  762.     if (PCLZIP_ERROR_EXTERNAL == 1) {
  763.       return(PclErrorString());
  764.     }
  765.     else {
  766.       if ($p_full) {
  767.         return($this->errorName(true)." : ".$this->error_string);
  768.       }
  769.       else {
  770.         return($this->error_string." [code ".$this->error_code."]");
  771.       }
  772.     }
  773.   }
  774.   
  775.  
  776.  
  777.  
  778.  
  779.                               function privCheckFormat($p_level=0)
  780.   {
  781.     $v_result = true;
  782.  
  783. 	    clearstatcache();
  784.  
  785.         $this->privErrorReset();
  786.  
  787.         if (!is_file($this->zipname)) {
  788.             PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");
  789.       return(false);
  790.     }
  791.  
  792.         if (!is_readable($this->zipname)) {
  793.             PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");
  794.       return(false);
  795.     }
  796.  
  797.         
  798.         
  799.         
  800.         return $v_result;
  801.   }
  802.   
  803.                                 function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)
  804.   {
  805.     $v_result=1;
  806.     
  807.         $i=0;
  808.     while ($i<$p_size) {
  809.  
  810.             if (!isset($v_requested_options[$p_options_list[$i]])) {
  811.                 PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");
  812.  
  813.                 return PclZip::errorCode();
  814.       }
  815.  
  816.             switch ($p_options_list[$i]) {
  817.                 case PCLZIP_OPT_PATH :
  818.         case PCLZIP_OPT_REMOVE_PATH :
  819.         case PCLZIP_OPT_ADD_PATH :
  820.                     if (($i+1) >= $p_size) {
  821.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  822.  
  823.                         return PclZip::errorCode();
  824.           }
  825.  
  826.                     $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
  827.           $i++;
  828.         break;
  829.  
  830.         case PCLZIP_OPT_TEMP_FILE_THRESHOLD :
  831.                     if (($i+1) >= $p_size) {
  832.             PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  833.             return PclZip::errorCode();
  834.           }
  835.           
  836.                     if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
  837.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
  838.             return PclZip::errorCode();
  839.           }
  840.           
  841.                     $v_value = $p_options_list[$i+1];
  842.           if ((!is_integer($v_value)) || ($v_value<0)) {
  843.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Integer expected for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  844.             return PclZip::errorCode();
  845.           }
  846.  
  847.                     $v_result_list[$p_options_list[$i]] = $v_value*1048576;
  848.           $i++;
  849.         break;
  850.  
  851.         case PCLZIP_OPT_TEMP_FILE_ON :
  852.                     if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_OFF])) {
  853.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_OFF'");
  854.             return PclZip::errorCode();
  855.           }
  856.           
  857.           $v_result_list[$p_options_list[$i]] = true;
  858.         break;
  859.  
  860.         case PCLZIP_OPT_TEMP_FILE_OFF :
  861.                     if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_ON])) {
  862.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_ON'");
  863.             return PclZip::errorCode();
  864.           }
  865.                     if (isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
  866.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Option '".PclZipUtilOptionText($p_options_list[$i])."' can not be used with option 'PCLZIP_OPT_TEMP_FILE_THRESHOLD'");
  867.             return PclZip::errorCode();
  868.           }
  869.           
  870.           $v_result_list[$p_options_list[$i]] = true;
  871.         break;
  872.  
  873.         case PCLZIP_OPT_EXTRACT_DIR_RESTRICTION :
  874.                     if (($i+1) >= $p_size) {
  875.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  876.  
  877.                         return PclZip::errorCode();
  878.           }
  879.  
  880.                     if (   is_string($p_options_list[$i+1])
  881.               && ($p_options_list[$i+1] != '')) {
  882.             $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);
  883.             $i++;
  884.           }
  885.           else {
  886.           }
  887.         break;
  888.  
  889.                 case PCLZIP_OPT_BY_NAME :
  890.                     if (($i+1) >= $p_size) {
  891.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  892.  
  893.                         return PclZip::errorCode();
  894.           }
  895.  
  896.                     if (is_string($p_options_list[$i+1])) {
  897.               $v_result_list[$p_options_list[$i]][0] = $p_options_list[$i+1];
  898.           }
  899.           else if (is_array($p_options_list[$i+1])) {
  900.               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
  901.           }
  902.           else {
  903.                         PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  904.  
  905.                         return PclZip::errorCode();
  906.           }
  907.           $i++;
  908.         break;
  909.  
  910.                 case PCLZIP_OPT_BY_EREG :
  911.                               $p_options_list[$i] = PCLZIP_OPT_BY_PREG;
  912.         case PCLZIP_OPT_BY_PREG :
  913.                             if (($i+1) >= $p_size) {
  914.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  915.  
  916.                         return PclZip::errorCode();
  917.           }
  918.  
  919.                     if (is_string($p_options_list[$i+1])) {
  920.               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
  921.           }
  922.           else {
  923.                         PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  924.  
  925.                         return PclZip::errorCode();
  926.           }
  927.           $i++;
  928.         break;
  929.  
  930.                 case PCLZIP_OPT_COMMENT :
  931.         case PCLZIP_OPT_ADD_COMMENT :
  932.         case PCLZIP_OPT_PREPEND_COMMENT :
  933.                     if (($i+1) >= $p_size) {
  934.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE,
  935. 			                     "Missing parameter value for option '"
  936. 								 .PclZipUtilOptionText($p_options_list[$i])
  937. 								 ."'");
  938.  
  939.                         return PclZip::errorCode();
  940.           }
  941.  
  942.                     if (is_string($p_options_list[$i+1])) {
  943.               $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
  944.           }
  945.           else {
  946.                         PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE,
  947. 			                     "Wrong parameter value for option '"
  948. 								 .PclZipUtilOptionText($p_options_list[$i])
  949. 								 ."'");
  950.  
  951.                         return PclZip::errorCode();
  952.           }
  953.           $i++;
  954.         break;
  955.  
  956.                 case PCLZIP_OPT_BY_INDEX :
  957.                     if (($i+1) >= $p_size) {
  958.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  959.  
  960.                         return PclZip::errorCode();
  961.           }
  962.  
  963.                     $v_work_list = array();
  964.           if (is_string($p_options_list[$i+1])) {
  965.  
  966.                             $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');
  967.  
  968.                             $v_work_list = explode(",", $p_options_list[$i+1]);
  969.           }
  970.           else if (is_integer($p_options_list[$i+1])) {
  971.               $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];
  972.           }
  973.           else if (is_array($p_options_list[$i+1])) {
  974.               $v_work_list = $p_options_list[$i+1];
  975.           }
  976.           else {
  977.                         PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  978.  
  979.                         return PclZip::errorCode();
  980.           }
  981.           
  982.                                                   $v_sort_flag=false;
  983.           $v_sort_value=0;
  984.           for ($j=0; $j<sizeof($v_work_list); $j++) {
  985.                             $v_item_list = explode("-", $v_work_list[$j]);
  986.               $v_size_item_list = sizeof($v_item_list);
  987.               
  988.                                           
  989.                             if ($v_size_item_list == 1) {
  990.                                     $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
  991.                   $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[0];
  992.               }
  993.               elseif ($v_size_item_list == 2) {
  994.                                     $v_result_list[$p_options_list[$i]][$j]['start'] = $v_item_list[0];
  995.                   $v_result_list[$p_options_list[$i]][$j]['end'] = $v_item_list[1];
  996.               }
  997.               else {
  998.                                     PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  999.  
  1000.                                     return PclZip::errorCode();
  1001.               }
  1002.  
  1003.  
  1004.                             if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {
  1005.                   $v_sort_flag=true;
  1006.  
  1007.                                                       PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  1008.  
  1009.                                     return PclZip::errorCode();
  1010.               }
  1011.               $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];
  1012.           }
  1013.           
  1014.                     if ($v_sort_flag) {
  1015.                         }
  1016.  
  1017.                     $i++;
  1018.         break;
  1019.  
  1020.                 case PCLZIP_OPT_REMOVE_ALL_PATH :
  1021.         case PCLZIP_OPT_EXTRACT_AS_STRING :
  1022.         case PCLZIP_OPT_NO_COMPRESSION :
  1023.         case PCLZIP_OPT_EXTRACT_IN_OUTPUT :
  1024.         case PCLZIP_OPT_REPLACE_NEWER :
  1025.         case PCLZIP_OPT_STOP_ON_ERROR :
  1026.           $v_result_list[$p_options_list[$i]] = true;
  1027.         break;
  1028.  
  1029.                 case PCLZIP_OPT_SET_CHMOD :
  1030.                     if (($i+1) >= $p_size) {
  1031.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  1032.  
  1033.                         return PclZip::errorCode();
  1034.           }
  1035.  
  1036.                     $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];
  1037.           $i++;
  1038.         break;
  1039.  
  1040.                 case PCLZIP_CB_PRE_EXTRACT :
  1041.         case PCLZIP_CB_POST_EXTRACT :
  1042.         case PCLZIP_CB_PRE_ADD :
  1043.         case PCLZIP_CB_POST_ADD :
  1044.  
  1045.                     if (($i+1) >= $p_size) {
  1046.                         PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  1047.  
  1048.                         return PclZip::errorCode();
  1049.           }
  1050.  
  1051.                     $v_function_name = $p_options_list[$i+1];
  1052.  
  1053.                     if (!function_exists($v_function_name)) {
  1054.                         PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Function '".$v_function_name."()' is not an existing function for option '".PclZipUtilOptionText($p_options_list[$i])."'");
  1055.  
  1056.                         return PclZip::errorCode();
  1057.           }
  1058.  
  1059.                     $v_result_list[$p_options_list[$i]] = $v_function_name;
  1060.           $i++;
  1061.         break;
  1062.  
  1063.         default :
  1064.                     PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
  1065. 		                       "Unknown parameter '"
  1066. 							   .$p_options_list[$i]."'");
  1067.  
  1068.                     return PclZip::errorCode();
  1069.       }
  1070.  
  1071.             $i++;
  1072.     }
  1073.  
  1074.         if ($v_requested_options !== false) {
  1075.       for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
  1076.                 if ($v_requested_options[$key] == 'mandatory') {
  1077.                     if (!isset($v_result_list[$key])) {
  1078.                         PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
  1079.  
  1080.                         return PclZip::errorCode();
  1081.           }
  1082.         }
  1083.       }
  1084.     }
  1085.     
  1086.         if (!isset($v_result_list[PCLZIP_OPT_TEMP_FILE_THRESHOLD])) {
  1087.       
  1088.     }
  1089.  
  1090.         return $v_result;
  1091.   }
  1092.   
  1093.               function privOptionDefaultThreshold(&$p_options)
  1094.   {
  1095.     $v_result=1;
  1096.     
  1097.     if (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
  1098.         || isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) {
  1099.       return $v_result;
  1100.     }
  1101.     
  1102.         $v_memory_limit = ini_get('memory_limit');
  1103.     $v_memory_limit = trim($v_memory_limit);
  1104.     $last = strtolower(substr($v_memory_limit, -1));
  1105.  
  1106.     if($last == 'g')
  1107.                 $v_memory_limit = $v_memory_limit*1073741824;
  1108.     if($last == 'm')
  1109.                 $v_memory_limit = $v_memory_limit*1048576;
  1110.     if($last == 'k')
  1111.         $v_memory_limit = $v_memory_limit*1024;
  1112.             
  1113.     $p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] = floor($v_memory_limit*PCLZIP_TEMPORARY_FILE_RATIO);
  1114.     
  1115.  
  1116.         if ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] < 1048576) {
  1117.       unset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD]);
  1118.     }
  1119.           
  1120.         return $v_result;
  1121.   }
  1122.   
  1123.                   function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)
  1124.   {
  1125.     $v_result=1;
  1126.     
  1127.         foreach ($p_file_list as $v_key => $v_value) {
  1128.     
  1129.             if (!isset($v_requested_options[$v_key])) {
  1130.                 PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");
  1131.  
  1132.                 return PclZip::errorCode();
  1133.       }
  1134.  
  1135.             switch ($v_key) {
  1136.         case PCLZIP_ATT_FILE_NAME :
  1137.           if (!is_string($v_value)) {
  1138.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
  1139.             return PclZip::errorCode();
  1140.           }
  1141.  
  1142.           $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);
  1143.           
  1144.           if ($p_filedescr['filename'] == '') {
  1145.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");
  1146.             return PclZip::errorCode();
  1147.           }
  1148.  
  1149.         break;
  1150.  
  1151.         case PCLZIP_ATT_FILE_NEW_SHORT_NAME :
  1152.           if (!is_string($v_value)) {
  1153.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
  1154.             return PclZip::errorCode();
  1155.           }
  1156.  
  1157.           $p_filedescr['new_short_name'] = PclZipUtilPathReduction($v_value);
  1158.  
  1159.           if ($p_filedescr['new_short_name'] == '') {
  1160.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");
  1161.             return PclZip::errorCode();
  1162.           }
  1163.         break;
  1164.  
  1165.         case PCLZIP_ATT_FILE_NEW_FULL_NAME :
  1166.           if (!is_string($v_value)) {
  1167.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
  1168.             return PclZip::errorCode();
  1169.           }
  1170.  
  1171.           $p_filedescr['new_full_name'] = PclZipUtilPathReduction($v_value);
  1172.  
  1173.           if ($p_filedescr['new_full_name'] == '') {
  1174.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");
  1175.             return PclZip::errorCode();
  1176.           }
  1177.         break;
  1178.  
  1179.                 case PCLZIP_ATT_FILE_COMMENT :
  1180.           if (!is_string($v_value)) {
  1181.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");
  1182.             return PclZip::errorCode();
  1183.           }
  1184.  
  1185.           $p_filedescr['comment'] = $v_value;
  1186.         break;
  1187.  
  1188.         case PCLZIP_ATT_FILE_MTIME :
  1189.           if (!is_integer($v_value)) {
  1190.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". Integer expected for attribute '".PclZipUtilOptionText($v_key)."'");
  1191.             return PclZip::errorCode();
  1192.           }
  1193.  
  1194.           $p_filedescr['mtime'] = $v_value;
  1195.         break;
  1196.  
  1197.         case PCLZIP_ATT_FILE_CONTENT :
  1198.           $p_filedescr['content'] = $v_value;
  1199.         break;
  1200.  
  1201.         default :
  1202.                     PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,
  1203. 		                           "Unknown parameter '".$v_key."'");
  1204.  
  1205.                     return PclZip::errorCode();
  1206.       }
  1207.  
  1208.             if ($v_requested_options !== false) {
  1209.         for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {
  1210.                     if ($v_requested_options[$key] == 'mandatory') {
  1211.                         if (!isset($p_file_list[$key])) {
  1212.               PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");
  1213.               return PclZip::errorCode();
  1214.             }
  1215.           }
  1216.         }
  1217.       }
  1218.     
  1219.         }
  1220.     
  1221.         return $v_result;
  1222.   }
  1223.   
  1224.                               function privFileDescrExpand(&$p_filedescr_list, &$p_options)
  1225.   {
  1226.     $v_result=1;
  1227.     
  1228.         $v_result_list = array();
  1229.     
  1230.         for ($i=0; $i<sizeof($p_filedescr_list); $i++) {
  1231.       
  1232.             $v_descr = $p_filedescr_list[$i];
  1233.       
  1234.             $v_descr['filename'] = PclZipUtilTranslateWinPath($v_descr['filename'], false);
  1235.       $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);
  1236.       
  1237.             if (file_exists($v_descr['filename'])) {
  1238.         if (@is_file($v_descr['filename'])) {
  1239.           $v_descr['type'] = 'file';
  1240.         }
  1241.         else if (@is_dir($v_descr['filename'])) {
  1242.           $v_descr['type'] = 'folder';
  1243.         }
  1244.         else if (@is_link($v_descr['filename'])) {
  1245.                     continue;
  1246.         }
  1247.         else {
  1248.                     continue;
  1249.         }
  1250.       }
  1251.       
  1252.             else if (isset($v_descr['content'])) {
  1253.         $v_descr['type'] = 'virtual_file';
  1254.       }
  1255.       
  1256.             else {
  1257.                 PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$v_descr['filename']."' does not exist");
  1258.  
  1259.                 return PclZip::errorCode();
  1260.       }
  1261.       
  1262.             $this->privCalculateStoredFilename($v_descr, $p_options);
  1263.       
  1264.             $v_result_list[sizeof($v_result_list)] = $v_descr;
  1265.       
  1266.             if ($v_descr['type'] == 'folder') {
  1267.                 $v_dirlist_descr = array();
  1268.         $v_dirlist_nb = 0;
  1269.         if ($v_folder_handler = @opendir($v_descr['filename'])) {
  1270.           while (($v_item_handler = @readdir($v_folder_handler)) !== false) {
  1271.  
  1272.                         if (($v_item_handler == '.') || ($v_item_handler == '..')) {
  1273.                 continue;
  1274.             }
  1275.             
  1276.                         $v_dirlist_descr[$v_dirlist_nb]['filename'] = $v_descr['filename'].'/'.$v_item_handler;
  1277.             
  1278.                                                 if (($v_descr['stored_filename'] != $v_descr['filename'])
  1279.                  && (!isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))) {
  1280.               if ($v_descr['stored_filename'] != '') {
  1281.                 $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;
  1282.               }
  1283.               else {
  1284.                 $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_item_handler;
  1285.               }
  1286.             }
  1287.       
  1288.             $v_dirlist_nb++;
  1289.           }
  1290.           
  1291.           @closedir($v_folder_handler);
  1292.         }
  1293.         else {
  1294.                   }
  1295.         
  1296.                 if ($v_dirlist_nb != 0) {
  1297.                     if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {
  1298.             return $v_result;
  1299.           }
  1300.           
  1301.                     $v_result_list = array_merge($v_result_list, $v_dirlist_descr);
  1302.         }
  1303.         else {
  1304.         }
  1305.           
  1306.                 unset($v_dirlist_descr);
  1307.       }
  1308.     }
  1309.     
  1310.         $p_filedescr_list = $v_result_list;
  1311.  
  1312.         return $v_result;
  1313.   }
  1314.   
  1315.               function privCreate($p_filedescr_list, &$p_result_list, &$p_options)
  1316.   {
  1317.     $v_result=1;
  1318.     $v_list_detail = array();
  1319.     
  1320.         $this->privDisableMagicQuotes();
  1321.  
  1322.         if (($v_result = $this->privOpenFd('wb')) != 1)
  1323.     {
  1324.             return $v_result;
  1325.     }
  1326.  
  1327.         $v_result = $this->privAddList($p_filedescr_list, $p_result_list, $p_options);
  1328.  
  1329.         $this->privCloseFd();
  1330.  
  1331.         $this->privSwapBackMagicQuotes();
  1332.  
  1333.         return $v_result;
  1334.   }
  1335.   
  1336.               function privAdd($p_filedescr_list, &$p_result_list, &$p_options)
  1337.   {
  1338.     $v_result=1;
  1339.     $v_list_detail = array();
  1340.  
  1341.         if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0))
  1342.     {
  1343.  
  1344.             $v_result = $this->privCreate($p_filedescr_list, $p_result_list, $p_options);
  1345.  
  1346.             return $v_result;
  1347.     }
  1348.         $this->privDisableMagicQuotes();
  1349.  
  1350.         if (($v_result=$this->privOpenFd('rb')) != 1)
  1351.     {
  1352.             $this->privSwapBackMagicQuotes();
  1353.  
  1354.             return $v_result;
  1355.     }
  1356.  
  1357.         $v_central_dir = array();
  1358.     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
  1359.     {
  1360.       $this->privCloseFd();
  1361.       $this->privSwapBackMagicQuotes();
  1362.       return $v_result;
  1363.     }
  1364.  
  1365.         @rewind($this->zip_fd);
  1366.  
  1367.         $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
  1368.  
  1369.         if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
  1370.     {
  1371.       $this->privCloseFd();
  1372.       $this->privSwapBackMagicQuotes();
  1373.  
  1374.       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
  1375.  
  1376.             return PclZip::errorCode();
  1377.     }
  1378.  
  1379.             $v_size = $v_central_dir['offset'];
  1380.     while ($v_size != 0)
  1381.     {
  1382.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  1383.       $v_buffer = fread($this->zip_fd, $v_read_size);
  1384.       @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
  1385.       $v_size -= $v_read_size;
  1386.     }
  1387.  
  1388.                 $v_swap = $this->zip_fd;
  1389.     $this->zip_fd = $v_zip_temp_fd;
  1390.     $v_zip_temp_fd = $v_swap;
  1391.  
  1392.         $v_header_list = array();
  1393.     if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
  1394.     {
  1395.       fclose($v_zip_temp_fd);
  1396.       $this->privCloseFd();
  1397.       @unlink($v_zip_temp_name);
  1398.       $this->privSwapBackMagicQuotes();
  1399.  
  1400.             return $v_result;
  1401.     }
  1402.  
  1403.         $v_offset = @ftell($this->zip_fd);
  1404.  
  1405.         $v_size = $v_central_dir['size'];
  1406.     while ($v_size != 0)
  1407.     {
  1408.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  1409.       $v_buffer = @fread($v_zip_temp_fd, $v_read_size);
  1410.       @fwrite($this->zip_fd, $v_buffer, $v_read_size);
  1411.       $v_size -= $v_read_size;
  1412.     }
  1413.  
  1414.         for ($i=0, $v_count=0; $i<sizeof($v_header_list); $i++)
  1415.     {
  1416.             if ($v_header_list[$i]['status'] == 'ok') {
  1417.         if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
  1418.           fclose($v_zip_temp_fd);
  1419.           $this->privCloseFd();
  1420.           @unlink($v_zip_temp_name);
  1421.           $this->privSwapBackMagicQuotes();
  1422.  
  1423.                     return $v_result;
  1424.         }
  1425.         $v_count++;
  1426.       }
  1427.  
  1428.             $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
  1429.     }
  1430.  
  1431.         $v_comment = $v_central_dir['comment'];
  1432.     if (isset($p_options[PCLZIP_OPT_COMMENT])) {
  1433.       $v_comment = $p_options[PCLZIP_OPT_COMMENT];
  1434.     }
  1435.     if (isset($p_options[PCLZIP_OPT_ADD_COMMENT])) {
  1436.       $v_comment = $v_comment.$p_options[PCLZIP_OPT_ADD_COMMENT];
  1437.     }
  1438.     if (isset($p_options[PCLZIP_OPT_PREPEND_COMMENT])) {
  1439.       $v_comment = $p_options[PCLZIP_OPT_PREPEND_COMMENT].$v_comment;
  1440.     }
  1441.  
  1442.         $v_size = @ftell($this->zip_fd)-$v_offset;
  1443.  
  1444.         if (($v_result = $this->privWriteCentralHeader($v_count+$v_central_dir['entries'], $v_size, $v_offset, $v_comment)) != 1)
  1445.     {
  1446.             unset($v_header_list);
  1447.       $this->privSwapBackMagicQuotes();
  1448.  
  1449.             return $v_result;
  1450.     }
  1451.  
  1452.         $v_swap = $this->zip_fd;
  1453.     $this->zip_fd = $v_zip_temp_fd;
  1454.     $v_zip_temp_fd = $v_swap;
  1455.  
  1456.         $this->privCloseFd();
  1457.  
  1458.         @fclose($v_zip_temp_fd);
  1459.  
  1460.         $this->privSwapBackMagicQuotes();
  1461.  
  1462.             @unlink($this->zipname);
  1463.  
  1464.                 PclZipUtilRename($v_zip_temp_name, $this->zipname);
  1465.  
  1466.         return $v_result;
  1467.   }
  1468.   
  1469.             function privOpenFd($p_mode)
  1470.   {
  1471.     $v_result=1;
  1472.  
  1473.         if ($this->zip_fd != 0)
  1474.     {
  1475.             PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Zip file \''.$this->zipname.'\' already open');
  1476.  
  1477.             return PclZip::errorCode();
  1478.     }
  1479.  
  1480.         if (($this->zip_fd = @fopen($this->zipname, $p_mode)) == 0)
  1481.     {
  1482.             PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in '.$p_mode.' mode');
  1483.  
  1484.             return PclZip::errorCode();
  1485.     }
  1486.  
  1487.         return $v_result;
  1488.   }
  1489.   
  1490.             function privCloseFd()
  1491.   {
  1492.     $v_result=1;
  1493.  
  1494.     if ($this->zip_fd != 0)
  1495.       @fclose($this->zip_fd);
  1496.     $this->zip_fd = 0;
  1497.  
  1498.         return $v_result;
  1499.   }
  1500.   
  1501.                             function privAddList($p_filedescr_list, &$p_result_list, &$p_options)
  1502.   {
  1503.     $v_result=1;
  1504.  
  1505.         $v_header_list = array();
  1506.     if (($v_result = $this->privAddFileList($p_filedescr_list, $v_header_list, $p_options)) != 1)
  1507.     {
  1508.             return $v_result;
  1509.     }
  1510.  
  1511.         $v_offset = @ftell($this->zip_fd);
  1512.  
  1513.         for ($i=0,$v_count=0; $i<sizeof($v_header_list); $i++)
  1514.     {
  1515.             if ($v_header_list[$i]['status'] == 'ok') {
  1516.         if (($v_result = $this->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
  1517.                     return $v_result;
  1518.         }
  1519.         $v_count++;
  1520.       }
  1521.  
  1522.             $this->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
  1523.     }
  1524.  
  1525.         $v_comment = '';
  1526.     if (isset($p_options[PCLZIP_OPT_COMMENT])) {
  1527.       $v_comment = $p_options[PCLZIP_OPT_COMMENT];
  1528.     }
  1529.  
  1530.         $v_size = @ftell($this->zip_fd)-$v_offset;
  1531.  
  1532.         if (($v_result = $this->privWriteCentralHeader($v_count, $v_size, $v_offset, $v_comment)) != 1)
  1533.     {
  1534.             unset($v_header_list);
  1535.  
  1536.             return $v_result;
  1537.     }
  1538.  
  1539.         return $v_result;
  1540.   }
  1541.   
  1542.                     function privAddFileList($p_filedescr_list, &$p_result_list, &$p_options)
  1543.   {
  1544.     $v_result=1;
  1545.     $v_header = array();
  1546.  
  1547.         $v_nb = sizeof($p_result_list);
  1548.  
  1549.         for ($j=0; ($j<sizeof($p_filedescr_list)) && ($v_result==1); $j++) {
  1550.             $p_filedescr_list[$j]['filename']
  1551.       = PclZipUtilTranslateWinPath($p_filedescr_list[$j]['filename'], false);
  1552.       
  1553.  
  1554.                   if ($p_filedescr_list[$j]['filename'] == "") {
  1555.         continue;
  1556.       }
  1557.  
  1558.             if (   ($p_filedescr_list[$j]['type'] != 'virtual_file')
  1559.           && (!file_exists($p_filedescr_list[$j]['filename']))) {
  1560.         PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "File '".$p_filedescr_list[$j]['filename']."' does not exist");
  1561.         return PclZip::errorCode();
  1562.       }
  1563.  
  1564.                   if (   ($p_filedescr_list[$j]['type'] == 'file')
  1565.           || ($p_filedescr_list[$j]['type'] == 'virtual_file')
  1566.           || (   ($p_filedescr_list[$j]['type'] == 'folder')
  1567.               && (   !isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])
  1568.                   || !$p_options[PCLZIP_OPT_REMOVE_ALL_PATH]))
  1569.           ) {
  1570.  
  1571.                 $v_result = $this->privAddFile($p_filedescr_list[$j], $v_header,
  1572.                                        $p_options);
  1573.         if ($v_result != 1) {
  1574.           return $v_result;
  1575.         }
  1576.  
  1577.                 $p_result_list[$v_nb++] = $v_header;
  1578.       }
  1579.     }
  1580.  
  1581.         return $v_result;
  1582.   }
  1583.   
  1584.               function privAddFile($p_filedescr, &$p_header, &$p_options)
  1585.   {
  1586.     $v_result=1;
  1587.     
  1588.         $p_filename = $p_filedescr['filename'];
  1589.  
  1590.         if ($p_filename == "") {
  1591.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file list parameter (invalid or empty list)");
  1592.  
  1593.             return PclZip::errorCode();
  1594.     }
  1595.  
  1596.         clearstatcache();
  1597.     $p_header['version'] = 20;
  1598.     $p_header['version_extracted'] = 10;
  1599.     $p_header['flag'] = 0;
  1600.     $p_header['compression'] = 0;
  1601.     $p_header['crc'] = 0;
  1602.     $p_header['compressed_size'] = 0;
  1603.     $p_header['filename_len'] = strlen($p_filename);
  1604.     $p_header['extra_len'] = 0;
  1605.     $p_header['disk'] = 0;
  1606.     $p_header['internal'] = 0;
  1607.     $p_header['offset'] = 0;
  1608.     $p_header['filename'] = $p_filename;
  1609.     $p_header['stored_filename'] = $p_filedescr['stored_filename'];
  1610.     $p_header['extra'] = '';
  1611.     $p_header['status'] = 'ok';
  1612.     $p_header['index'] = -1;
  1613.  
  1614.         if ($p_filedescr['type']=='file') {
  1615.       $p_header['external'] = 0x00000000;
  1616.       $p_header['size'] = filesize($p_filename);
  1617.     }
  1618.     
  1619.         else if ($p_filedescr['type']=='folder') {
  1620.       $p_header['external'] = 0x00000010;
  1621.       $p_header['mtime'] = filemtime($p_filename);
  1622.       $p_header['size'] = filesize($p_filename);
  1623.     }
  1624.     
  1625.         else if ($p_filedescr['type'] == 'virtual_file') {
  1626.       $p_header['external'] = 0x00000000;
  1627.       $p_header['size'] = strlen($p_filedescr['content']);
  1628.     }
  1629.     
  1630.  
  1631.         if (isset($p_filedescr['mtime'])) {
  1632.       $p_header['mtime'] = $p_filedescr['mtime'];
  1633.     }
  1634.     else if ($p_filedescr['type'] == 'virtual_file') {
  1635.       $p_header['mtime'] = time();
  1636.     }
  1637.     else {
  1638.       $p_header['mtime'] = filemtime($p_filename);
  1639.     }
  1640.  
  1641.         if (isset($p_filedescr['comment'])) {
  1642.       $p_header['comment_len'] = strlen($p_filedescr['comment']);
  1643.       $p_header['comment'] = $p_filedescr['comment'];
  1644.     }
  1645.     else {
  1646.       $p_header['comment_len'] = 0;
  1647.       $p_header['comment'] = '';
  1648.     }
  1649.  
  1650.         if (isset($p_options[PCLZIP_CB_PRE_ADD])) {
  1651.  
  1652.             $v_local_header = array();
  1653.       $this->privConvertHeader2FileInfo($p_header, $v_local_header);
  1654.  
  1655.                         $v_result = $p_options[PCLZIP_CB_PRE_ADD](PCLZIP_CB_PRE_ADD, $v_local_header);
  1656.       if ($v_result == 0) {
  1657.                 $p_header['status'] = "skipped";
  1658.         $v_result = 1;
  1659.       }
  1660.  
  1661.                   if ($p_header['stored_filename'] != $v_local_header['stored_filename']) {
  1662.         $p_header['stored_filename'] = PclZipUtilPathReduction($v_local_header['stored_filename']);
  1663.       }
  1664.     }
  1665.  
  1666.         if ($p_header['stored_filename'] == "") {
  1667.       $p_header['status'] = "filtered";
  1668.     }
  1669.     
  1670.         if (strlen($p_header['stored_filename']) > 0xFF) {
  1671.       $p_header['status'] = 'filename_too_long';
  1672.     }
  1673.  
  1674.         if ($p_header['status'] == 'ok') {
  1675.  
  1676.             if ($p_filedescr['type'] == 'file') {
  1677.                 if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) 
  1678.             && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
  1679.                 || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
  1680.                     && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_header['size'])) ) ) {
  1681.           $v_result = $this->privAddFileUsingTempFile($p_filedescr, $p_header, $p_options);
  1682.           if ($v_result < PCLZIP_ERR_NO_ERROR) {
  1683.             return $v_result;
  1684.           }
  1685.         }
  1686.         
  1687.                 else {
  1688.  
  1689.                 if (($v_file = @fopen($p_filename, "rb")) == 0) {
  1690.           PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
  1691.           return PclZip::errorCode();
  1692.         }
  1693.  
  1694.                 $v_content = @fread($v_file, $p_header['size']);
  1695.  
  1696.                 @fclose($v_file);
  1697.  
  1698.                 $p_header['crc'] = @crc32($v_content);
  1699.         
  1700.                 if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
  1701.                     $p_header['compressed_size'] = $p_header['size'];
  1702.           $p_header['compression'] = 0;
  1703.         }
  1704.         
  1705.                 else {
  1706.                     $v_content = @gzdeflate($v_content);
  1707.  
  1708.                     $p_header['compressed_size'] = strlen($v_content);
  1709.           $p_header['compression'] = 8;
  1710.         }
  1711.         
  1712.                 if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
  1713.           @fclose($v_file);
  1714.           return $v_result;
  1715.         }
  1716.  
  1717.                 @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
  1718.  
  1719.         }
  1720.  
  1721.       }
  1722.  
  1723.             else if ($p_filedescr['type'] == 'virtual_file') {
  1724.           
  1725.         $v_content = $p_filedescr['content'];
  1726.  
  1727.                 $p_header['crc'] = @crc32($v_content);
  1728.         
  1729.                 if ($p_options[PCLZIP_OPT_NO_COMPRESSION]) {
  1730.                     $p_header['compressed_size'] = $p_header['size'];
  1731.           $p_header['compression'] = 0;
  1732.         }
  1733.         
  1734.                 else {
  1735.                     $v_content = @gzdeflate($v_content);
  1736.  
  1737.                     $p_header['compressed_size'] = strlen($v_content);
  1738.           $p_header['compression'] = 8;
  1739.         }
  1740.         
  1741.                 if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
  1742.           @fclose($v_file);
  1743.           return $v_result;
  1744.         }
  1745.  
  1746.                 @fwrite($this->zip_fd, $v_content, $p_header['compressed_size']);
  1747.       }
  1748.  
  1749.             else if ($p_filedescr['type'] == 'folder') {
  1750.                 if (@substr($p_header['stored_filename'], -1) != '/') {
  1751.           $p_header['stored_filename'] .= '/';
  1752.         }
  1753.  
  1754.                 $p_header['size'] = 0;
  1755.                 $p_header['external'] = 0x00000010;   
  1756.                 if (($v_result = $this->privWriteFileHeader($p_header)) != 1)
  1757.         {
  1758.           return $v_result;
  1759.         }
  1760.       }
  1761.     }
  1762.  
  1763.         if (isset($p_options[PCLZIP_CB_POST_ADD])) {
  1764.  
  1765.             $v_local_header = array();
  1766.       $this->privConvertHeader2FileInfo($p_header, $v_local_header);
  1767.  
  1768.                         $v_result = $p_options[PCLZIP_CB_POST_ADD](PCLZIP_CB_POST_ADD, $v_local_header);
  1769.       if ($v_result == 0) {
  1770.                 $v_result = 1;
  1771.       }
  1772.  
  1773.                 }
  1774.  
  1775.         return $v_result;
  1776.   }
  1777.   
  1778.               function privAddFileUsingTempFile($p_filedescr, &$p_header, &$p_options)
  1779.   {
  1780.     $v_result=PCLZIP_ERR_NO_ERROR;
  1781.     
  1782.         $p_filename = $p_filedescr['filename'];
  1783.  
  1784.  
  1785.         if (($v_file = @fopen($p_filename, "rb")) == 0) {
  1786.       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to open file '$p_filename' in binary read mode");
  1787.       return PclZip::errorCode();
  1788.     }
  1789.  
  1790.         $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
  1791.     if (($v_file_compressed = @gzopen($v_gzip_temp_name, "wb")) == 0) {
  1792.       fclose($v_file);
  1793.       PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
  1794.       return PclZip::errorCode();
  1795.     }
  1796.  
  1797.         $v_size = filesize($p_filename);
  1798.     while ($v_size != 0) {
  1799.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  1800.       $v_buffer = @fread($v_file, $v_read_size);
  1801.             @gzputs($v_file_compressed, $v_buffer, $v_read_size);
  1802.       $v_size -= $v_read_size;
  1803.     }
  1804.  
  1805.         @fclose($v_file);
  1806.     @gzclose($v_file_compressed);
  1807.  
  1808.         if (filesize($v_gzip_temp_name) < 18) {
  1809.       PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'gzip temporary file \''.$v_gzip_temp_name.'\' has invalid filesize - should be minimum 18 bytes');
  1810.       return PclZip::errorCode();
  1811.     }
  1812.  
  1813.         if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0) {
  1814.       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
  1815.       return PclZip::errorCode();
  1816.     }
  1817.  
  1818.         $v_binary_data = @fread($v_file_compressed, 10);
  1819.     $v_data_header = unpack('a1id1/a1id2/a1cm/a1flag/Vmtime/a1xfl/a1os', $v_binary_data);
  1820.  
  1821.         $v_data_header['os'] = bin2hex($v_data_header['os']);
  1822.  
  1823.         @fseek($v_file_compressed, filesize($v_gzip_temp_name)-8);
  1824.     $v_binary_data = @fread($v_file_compressed, 8);
  1825.     $v_data_footer = unpack('Vcrc/Vcompressed_size', $v_binary_data);
  1826.  
  1827.         $p_header['compression'] = ord($v_data_header['cm']);
  1828.         $p_header['crc'] = $v_data_footer['crc'];
  1829.     $p_header['compressed_size'] = filesize($v_gzip_temp_name)-18;
  1830.  
  1831.         @fclose($v_file_compressed);
  1832.  
  1833.         if (($v_result = $this->privWriteFileHeader($p_header)) != 1) {
  1834.       return $v_result;
  1835.     }
  1836.  
  1837.         if (($v_file_compressed = @fopen($v_gzip_temp_name, "rb")) == 0)
  1838.     {
  1839.       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
  1840.       return PclZip::errorCode();
  1841.     }
  1842.  
  1843.         fseek($v_file_compressed, 10);
  1844.     $v_size = $p_header['compressed_size'];
  1845.     while ($v_size != 0)
  1846.     {
  1847.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  1848.       $v_buffer = @fread($v_file_compressed, $v_read_size);
  1849.             @fwrite($this->zip_fd, $v_buffer, $v_read_size);
  1850.       $v_size -= $v_read_size;
  1851.     }
  1852.  
  1853.         @fclose($v_file_compressed);
  1854.  
  1855.         @unlink($v_gzip_temp_name);
  1856.     
  1857.         return $v_result;
  1858.   }
  1859.   
  1860.                   function privCalculateStoredFilename(&$p_filedescr, &$p_options)
  1861.   {
  1862.     $v_result=1;
  1863.     
  1864.         $p_filename = $p_filedescr['filename'];
  1865.     if (isset($p_options[PCLZIP_OPT_ADD_PATH])) {
  1866.       $p_add_dir = $p_options[PCLZIP_OPT_ADD_PATH];
  1867.     }
  1868.     else {
  1869.       $p_add_dir = '';
  1870.     }
  1871.     if (isset($p_options[PCLZIP_OPT_REMOVE_PATH])) {
  1872.       $p_remove_dir = $p_options[PCLZIP_OPT_REMOVE_PATH];
  1873.     }
  1874.     else {
  1875.       $p_remove_dir = '';
  1876.     }
  1877.     if (isset($p_options[PCLZIP_OPT_REMOVE_ALL_PATH])) {
  1878.       $p_remove_all_dir = $p_options[PCLZIP_OPT_REMOVE_ALL_PATH];
  1879.     }
  1880.     else {
  1881.       $p_remove_all_dir = 0;
  1882.     }
  1883.  
  1884.  
  1885.         if (isset($p_filedescr['new_full_name'])) {
  1886.             $v_stored_filename = PclZipUtilTranslateWinPath($p_filedescr['new_full_name']);
  1887.     }
  1888.     
  1889.         else {
  1890.  
  1891.                   if (isset($p_filedescr['new_short_name'])) {
  1892.         $v_path_info = pathinfo($p_filename);
  1893.         $v_dir = '';
  1894.         if ($v_path_info['dirname'] != '') {
  1895.           $v_dir = $v_path_info['dirname'].'/';
  1896.         }
  1897.         $v_stored_filename = $v_dir.$p_filedescr['new_short_name'];
  1898.       }
  1899.       else {
  1900.                 $v_stored_filename = $p_filename;
  1901.       }
  1902.  
  1903.             if ($p_remove_all_dir) {
  1904.         $v_stored_filename = basename($p_filename);
  1905.       }
  1906.             else if ($p_remove_dir != "") {
  1907.         if (substr($p_remove_dir, -1) != '/')
  1908.           $p_remove_dir .= "/";
  1909.  
  1910.         if (   (substr($p_filename, 0, 2) == "./")
  1911.             || (substr($p_remove_dir, 0, 2) == "./")) {
  1912.             
  1913.           if (   (substr($p_filename, 0, 2) == "./")
  1914.               && (substr($p_remove_dir, 0, 2) != "./")) {
  1915.             $p_remove_dir = "./".$p_remove_dir;
  1916.           }
  1917.           if (   (substr($p_filename, 0, 2) != "./")
  1918.               && (substr($p_remove_dir, 0, 2) == "./")) {
  1919.             $p_remove_dir = substr($p_remove_dir, 2);
  1920.           }
  1921.         }
  1922.  
  1923.         $v_compare = PclZipUtilPathInclusion($p_remove_dir,
  1924.                                              $v_stored_filename);
  1925.         if ($v_compare > 0) {
  1926.           if ($v_compare == 2) {
  1927.             $v_stored_filename = "";
  1928.           }
  1929.           else {
  1930.             $v_stored_filename = substr($v_stored_filename,
  1931.                                         strlen($p_remove_dir));
  1932.           }
  1933.         }
  1934.       }
  1935.       
  1936.             $v_stored_filename = PclZipUtilTranslateWinPath($v_stored_filename);
  1937.       
  1938.             if ($p_add_dir != "") {
  1939.         if (substr($p_add_dir, -1) == "/")
  1940.           $v_stored_filename = $p_add_dir.$v_stored_filename;
  1941.         else
  1942.           $v_stored_filename = $p_add_dir."/".$v_stored_filename;
  1943.       }
  1944.     }
  1945.  
  1946.         $v_stored_filename = PclZipUtilPathReduction($v_stored_filename);
  1947.     $p_filedescr['stored_filename'] = $v_stored_filename;
  1948.     
  1949.         return $v_result;
  1950.   }
  1951.   
  1952.               function privWriteFileHeader(&$p_header)
  1953.   {
  1954.     $v_result=1;
  1955.  
  1956.         $p_header['offset'] = ftell($this->zip_fd);
  1957.  
  1958.         $v_date = getdate($p_header['mtime']);
  1959.     $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
  1960.     $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
  1961.  
  1962.         $v_binary_data = pack("VvvvvvVVVvv", 0x04034b50,
  1963. 	                      $p_header['version_extracted'], $p_header['flag'],
  1964.                           $p_header['compression'], $v_mtime, $v_mdate,
  1965.                           $p_header['crc'], $p_header['compressed_size'],
  1966. 						  $p_header['size'],
  1967.                           strlen($p_header['stored_filename']),
  1968. 						  $p_header['extra_len']);
  1969.  
  1970.         fputs($this->zip_fd, $v_binary_data, 30);
  1971.  
  1972.         if (strlen($p_header['stored_filename']) != 0)
  1973.     {
  1974.       fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
  1975.     }
  1976.     if ($p_header['extra_len'] != 0)
  1977.     {
  1978.       fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
  1979.     }
  1980.  
  1981.         return $v_result;
  1982.   }
  1983.   
  1984.               function privWriteCentralFileHeader(&$p_header)
  1985.   {
  1986.     $v_result=1;
  1987.  
  1988.             
  1989.         $v_date = getdate($p_header['mtime']);
  1990.     $v_mtime = ($v_date['hours']<<11) + ($v_date['minutes']<<5) + $v_date['seconds']/2;
  1991.     $v_mdate = (($v_date['year']-1980)<<9) + ($v_date['mon']<<5) + $v_date['mday'];
  1992.  
  1993.  
  1994.         $v_binary_data = pack("VvvvvvvVVVvvvvvVV", 0x02014b50,
  1995. 	                      $p_header['version'], $p_header['version_extracted'],
  1996.                           $p_header['flag'], $p_header['compression'],
  1997. 						  $v_mtime, $v_mdate, $p_header['crc'],
  1998.                           $p_header['compressed_size'], $p_header['size'],
  1999.                           strlen($p_header['stored_filename']),
  2000. 						  $p_header['extra_len'], $p_header['comment_len'],
  2001.                           $p_header['disk'], $p_header['internal'],
  2002. 						  $p_header['external'], $p_header['offset']);
  2003.  
  2004.         fputs($this->zip_fd, $v_binary_data, 46);
  2005.  
  2006.         if (strlen($p_header['stored_filename']) != 0)
  2007.     {
  2008.       fputs($this->zip_fd, $p_header['stored_filename'], strlen($p_header['stored_filename']));
  2009.     }
  2010.     if ($p_header['extra_len'] != 0)
  2011.     {
  2012.       fputs($this->zip_fd, $p_header['extra'], $p_header['extra_len']);
  2013.     }
  2014.     if ($p_header['comment_len'] != 0)
  2015.     {
  2016.       fputs($this->zip_fd, $p_header['comment'], $p_header['comment_len']);
  2017.     }
  2018.  
  2019.         return $v_result;
  2020.   }
  2021.   
  2022.               function privWriteCentralHeader($p_nb_entries, $p_size, $p_offset, $p_comment)
  2023.   {
  2024.     $v_result=1;
  2025.  
  2026.         $v_binary_data = pack("VvvvvVVv", 0x06054b50, 0, 0, $p_nb_entries,
  2027. 	                      $p_nb_entries, $p_size,
  2028. 						  $p_offset, strlen($p_comment));
  2029.  
  2030.         fputs($this->zip_fd, $v_binary_data, 22);
  2031.  
  2032.         if (strlen($p_comment) != 0)
  2033.     {
  2034.       fputs($this->zip_fd, $p_comment, strlen($p_comment));
  2035.     }
  2036.  
  2037.         return $v_result;
  2038.   }
  2039.   
  2040.               function privList(&$p_list)
  2041.   {
  2042.     $v_result=1;
  2043.  
  2044.         $this->privDisableMagicQuotes();
  2045.  
  2046.         if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)
  2047.     {
  2048.             $this->privSwapBackMagicQuotes();
  2049.       
  2050.             PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');
  2051.  
  2052.             return PclZip::errorCode();
  2053.     }
  2054.  
  2055.         $v_central_dir = array();
  2056.     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
  2057.     {
  2058.       $this->privSwapBackMagicQuotes();
  2059.       return $v_result;
  2060.     }
  2061.  
  2062.         @rewind($this->zip_fd);
  2063.     if (@fseek($this->zip_fd, $v_central_dir['offset']))
  2064.     {
  2065.       $this->privSwapBackMagicQuotes();
  2066.  
  2067.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
  2068.  
  2069.             return PclZip::errorCode();
  2070.     }
  2071.  
  2072.         for ($i=0; $i<$v_central_dir['entries']; $i++)
  2073.     {
  2074.             if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
  2075.       {
  2076.         $this->privSwapBackMagicQuotes();
  2077.         return $v_result;
  2078.       }
  2079.       $v_header['index'] = $i;
  2080.  
  2081.             $this->privConvertHeader2FileInfo($v_header, $p_list[$i]);
  2082.       unset($v_header);
  2083.     }
  2084.  
  2085.         $this->privCloseFd();
  2086.  
  2087.         $this->privSwapBackMagicQuotes();
  2088.  
  2089.         return $v_result;
  2090.   }
  2091.   
  2092.                                         function privConvertHeader2FileInfo($p_header, &$p_info)
  2093.   {
  2094.     $v_result=1;
  2095.  
  2096.         $v_temp_path = PclZipUtilPathReduction($p_header['filename']);
  2097.     $p_info['filename'] = $v_temp_path;
  2098.     $v_temp_path = PclZipUtilPathReduction($p_header['stored_filename']);
  2099.     $p_info['stored_filename'] = $v_temp_path;
  2100.     $p_info['size'] = $p_header['size'];
  2101.     $p_info['compressed_size'] = $p_header['compressed_size'];
  2102.     $p_info['mtime'] = $p_header['mtime'];
  2103.     $p_info['comment'] = $p_header['comment'];
  2104.     $p_info['folder'] = (($p_header['external']&0x00000010)==0x00000010);
  2105.     $p_info['index'] = $p_header['index'];
  2106.     $p_info['status'] = $p_header['status'];
  2107.     $p_info['crc'] = $p_header['crc'];
  2108.  
  2109.         return $v_result;
  2110.   }
  2111.   
  2112.                                   function privExtractByRule(&$p_file_list, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
  2113.   {
  2114.     $v_result=1;
  2115.  
  2116.         $this->privDisableMagicQuotes();
  2117.  
  2118.         if (   ($p_path == "")
  2119. 	    || (   (substr($p_path, 0, 1) != "/")
  2120. 		    && (substr($p_path, 0, 3) != "../")
  2121. 			&& (substr($p_path,1,2)!=":/")))
  2122.       $p_path = "./".$p_path;
  2123.  
  2124.         if (($p_path != "./") && ($p_path != "/"))
  2125.     {
  2126.             while (substr($p_path, -1) == "/")
  2127.       {
  2128.         $p_path = substr($p_path, 0, strlen($p_path)-1);
  2129.       }
  2130.     }
  2131.  
  2132.         if (($p_remove_path != "") && (substr($p_remove_path, -1) != '/'))
  2133.     {
  2134.       $p_remove_path .= '/';
  2135.     }
  2136.     $p_remove_path_size = strlen($p_remove_path);
  2137.  
  2138.         if (($v_result = $this->privOpenFd('rb')) != 1)
  2139.     {
  2140.       $this->privSwapBackMagicQuotes();
  2141.       return $v_result;
  2142.     }
  2143.  
  2144.         $v_central_dir = array();
  2145.     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
  2146.     {
  2147.             $this->privCloseFd();
  2148.       $this->privSwapBackMagicQuotes();
  2149.  
  2150.       return $v_result;
  2151.     }
  2152.  
  2153.         $v_pos_entry = $v_central_dir['offset'];
  2154.  
  2155.         $j_start = 0;
  2156.     for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
  2157.     {
  2158.  
  2159.             @rewind($this->zip_fd);
  2160.       if (@fseek($this->zip_fd, $v_pos_entry))
  2161.       {
  2162.                 $this->privCloseFd();
  2163.         $this->privSwapBackMagicQuotes();
  2164.  
  2165.                 PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
  2166.  
  2167.                 return PclZip::errorCode();
  2168.       }
  2169.  
  2170.             $v_header = array();
  2171.       if (($v_result = $this->privReadCentralFileHeader($v_header)) != 1)
  2172.       {
  2173.                 $this->privCloseFd();
  2174.         $this->privSwapBackMagicQuotes();
  2175.  
  2176.         return $v_result;
  2177.       }
  2178.  
  2179.             $v_header['index'] = $i;
  2180.  
  2181.             $v_pos_entry = ftell($this->zip_fd);
  2182.  
  2183.             $v_extract = false;
  2184.  
  2185.             if (   (isset($p_options[PCLZIP_OPT_BY_NAME]))
  2186.           && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
  2187.  
  2188.                     for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_extract); $j++) {
  2189.  
  2190.                             if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
  2191.  
  2192.                                     if (   (strlen($v_header['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
  2193.                       && (substr($v_header['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
  2194.                       $v_extract = true;
  2195.                   }
  2196.               }
  2197.                             elseif ($v_header['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
  2198.                   $v_extract = true;
  2199.               }
  2200.           }
  2201.       }
  2202.  
  2203.             else if (   (isset($p_options[PCLZIP_OPT_BY_PREG]))
  2204.                && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
  2205.  
  2206.           if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header['stored_filename'])) {
  2207.               $v_extract = true;
  2208.           }
  2209.       }
  2210.  
  2211.             else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX]))
  2212.                && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
  2213.           
  2214.                     for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_extract); $j++) {
  2215.  
  2216.               if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
  2217.                   $v_extract = true;
  2218.               }
  2219.               if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
  2220.                   $j_start = $j+1;
  2221.               }
  2222.  
  2223.               if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
  2224.                   break;
  2225.               }
  2226.           }
  2227.       }
  2228.  
  2229.             else {
  2230.           $v_extract = true;
  2231.       }
  2232.  
  2233. 	  	  if (   ($v_extract)
  2234. 	      && (   ($v_header['compression'] != 8)
  2235. 		      && ($v_header['compression'] != 0))) {
  2236.           $v_header['status'] = 'unsupported_compression';
  2237.  
  2238.                     if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
  2239. 		      && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
  2240.  
  2241.               $this->privSwapBackMagicQuotes();
  2242.               
  2243.               PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_COMPRESSION,
  2244. 			                       "Filename '".$v_header['stored_filename']."' is "
  2245. 				  	    	  	   ."compressed by an unsupported compression "
  2246. 				  	    	  	   ."method (".$v_header['compression'].") ");
  2247.  
  2248.               return PclZip::errorCode();
  2249. 		  }
  2250. 	  }
  2251. 	  
  2252. 	  	  if (($v_extract) && (($v_header['flag'] & 1) == 1)) {
  2253.           $v_header['status'] = 'unsupported_encryption';
  2254.  
  2255.                     if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
  2256. 		      && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
  2257.  
  2258.               $this->privSwapBackMagicQuotes();
  2259.  
  2260.               PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION,
  2261. 			                       "Unsupported encryption for "
  2262. 				  	    	  	   ." filename '".$v_header['stored_filename']
  2263. 								   ."'");
  2264.  
  2265.               return PclZip::errorCode();
  2266. 		  }
  2267.     }
  2268.  
  2269.             if (($v_extract) && ($v_header['status'] != 'ok')) {
  2270.           $v_result = $this->privConvertHeader2FileInfo($v_header,
  2271. 		                                        $p_file_list[$v_nb_extracted++]);
  2272.           if ($v_result != 1) {
  2273.               $this->privCloseFd();
  2274.               $this->privSwapBackMagicQuotes();
  2275.               return $v_result;
  2276.           }
  2277.  
  2278.           $v_extract = false;
  2279.       }
  2280.       
  2281.             if ($v_extract)
  2282.       {
  2283.  
  2284.                 @rewind($this->zip_fd);
  2285.         if (@fseek($this->zip_fd, $v_header['offset']))
  2286.         {
  2287.                     $this->privCloseFd();
  2288.  
  2289.           $this->privSwapBackMagicQuotes();
  2290.  
  2291.                     PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
  2292.  
  2293.                     return PclZip::errorCode();
  2294.         }
  2295.  
  2296.                 if ($p_options[PCLZIP_OPT_EXTRACT_AS_STRING]) {
  2297.  
  2298.           $v_string = '';
  2299.  
  2300.                     $v_result1 = $this->privExtractFileAsString($v_header, $v_string, $p_options);
  2301.           if ($v_result1 < 1) {
  2302.             $this->privCloseFd();
  2303.             $this->privSwapBackMagicQuotes();
  2304.             return $v_result1;
  2305.           }
  2306.  
  2307.                     if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted])) != 1)
  2308.           {
  2309.                         $this->privCloseFd();
  2310.             $this->privSwapBackMagicQuotes();
  2311.  
  2312.             return $v_result;
  2313.           }
  2314.  
  2315.                     $p_file_list[$v_nb_extracted]['content'] = $v_string;
  2316.  
  2317.                     $v_nb_extracted++;
  2318.           
  2319.                     if ($v_result1 == 2) {
  2320.           	break;
  2321.           }
  2322.         }
  2323.                 elseif (   (isset($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT]))
  2324. 		        && ($p_options[PCLZIP_OPT_EXTRACT_IN_OUTPUT])) {
  2325.                     $v_result1 = $this->privExtractFileInOutput($v_header, $p_options);
  2326.           if ($v_result1 < 1) {
  2327.             $this->privCloseFd();
  2328.             $this->privSwapBackMagicQuotes();
  2329.             return $v_result1;
  2330.           }
  2331.  
  2332.                     if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1) {
  2333.             $this->privCloseFd();
  2334.             $this->privSwapBackMagicQuotes();
  2335.             return $v_result;
  2336.           }
  2337.  
  2338.                     if ($v_result1 == 2) {
  2339.           	break;
  2340.           }
  2341.         }
  2342.                 else {
  2343.                     $v_result1 = $this->privExtractFile($v_header,
  2344. 		                                      $p_path, $p_remove_path,
  2345. 											  $p_remove_all_path,
  2346. 											  $p_options);
  2347.           if ($v_result1 < 1) {
  2348.             $this->privCloseFd();
  2349.             $this->privSwapBackMagicQuotes();
  2350.             return $v_result1;
  2351.           }
  2352.  
  2353.                     if (($v_result = $this->privConvertHeader2FileInfo($v_header, $p_file_list[$v_nb_extracted++])) != 1)
  2354.           {
  2355.                         $this->privCloseFd();
  2356.             $this->privSwapBackMagicQuotes();
  2357.  
  2358.             return $v_result;
  2359.           }
  2360.  
  2361.                     if ($v_result1 == 2) {
  2362.           	break;
  2363.           }
  2364.         }
  2365.       }
  2366.     }
  2367.  
  2368.         $this->privCloseFd();
  2369.     $this->privSwapBackMagicQuotes();
  2370.  
  2371.         return $v_result;
  2372.   }
  2373.   
  2374.                     function privExtractFile(&$p_entry, $p_path, $p_remove_path, $p_remove_all_path, &$p_options)
  2375.   {
  2376.     $v_result=1;
  2377.  
  2378.         if (($v_result = $this->privReadFileHeader($v_header)) != 1)
  2379.     {
  2380.             return $v_result;
  2381.     }
  2382.  
  2383.  
  2384.         if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
  2385.             }
  2386.  
  2387.         if ($p_remove_all_path == true) {
  2388.                 if (($p_entry['external']&0x00000010)==0x00000010) {
  2389.  
  2390.             $p_entry['status'] = "filtered";
  2391.  
  2392.             return $v_result;
  2393.         }
  2394.  
  2395.                 $p_entry['filename'] = basename($p_entry['filename']);
  2396.     }
  2397.  
  2398.         else if ($p_remove_path != "")
  2399.     {
  2400.       if (PclZipUtilPathInclusion($p_remove_path, $p_entry['filename']) == 2)
  2401.       {
  2402.  
  2403.                 $p_entry['status'] = "filtered";
  2404.  
  2405.                 return $v_result;
  2406.       }
  2407.  
  2408.       $p_remove_path_size = strlen($p_remove_path);
  2409.       if (substr($p_entry['filename'], 0, $p_remove_path_size) == $p_remove_path)
  2410.       {
  2411.  
  2412.                 $p_entry['filename'] = substr($p_entry['filename'], $p_remove_path_size);
  2413.  
  2414.       }
  2415.     }
  2416.  
  2417.         if ($p_path != '') {
  2418.       $p_entry['filename'] = $p_path."/".$p_entry['filename'];
  2419.     }
  2420.     
  2421.         if (isset($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION])) {
  2422.       $v_inclusion
  2423.       = PclZipUtilPathInclusion($p_options[PCLZIP_OPT_EXTRACT_DIR_RESTRICTION],
  2424.                                 $p_entry['filename']); 
  2425.       if ($v_inclusion == 0) {
  2426.  
  2427.         PclZip::privErrorLog(PCLZIP_ERR_DIRECTORY_RESTRICTION,
  2428. 			                     "Filename '".$p_entry['filename']."' is "
  2429. 								 ."outside PCLZIP_OPT_EXTRACT_DIR_RESTRICTION");
  2430.  
  2431.         return PclZip::errorCode();
  2432.       }
  2433.     }
  2434.  
  2435.         if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
  2436.  
  2437.             $v_local_header = array();
  2438.       $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
  2439.  
  2440.                         $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
  2441.       if ($v_result == 0) {
  2442.                 $p_entry['status'] = "skipped";
  2443.         $v_result = 1;
  2444.       }
  2445.       
  2446.             if ($v_result == 2) {
  2447.                 $p_entry['status'] = "aborted";
  2448.       	$v_result = PCLZIP_ERR_USER_ABORTED;
  2449.       }
  2450.  
  2451.                   $p_entry['filename'] = $v_local_header['filename'];
  2452.     }
  2453.  
  2454.  
  2455.         if ($p_entry['status'] == 'ok') {
  2456.  
  2457.         if (file_exists($p_entry['filename']))
  2458.     {
  2459.  
  2460.             if (is_dir($p_entry['filename']))
  2461.       {
  2462.  
  2463.                 $p_entry['status'] = "already_a_directory";
  2464.         
  2465.                                 if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
  2466. 		    && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
  2467.  
  2468.             PclZip::privErrorLog(PCLZIP_ERR_ALREADY_A_DIRECTORY,
  2469. 			                     "Filename '".$p_entry['filename']."' is "
  2470. 								 ."already used by an existing directory");
  2471.  
  2472.             return PclZip::errorCode();
  2473. 		    }
  2474.       }
  2475.             else if (!is_writeable($p_entry['filename']))
  2476.       {
  2477.  
  2478.                 $p_entry['status'] = "write_protected";
  2479.  
  2480.                                 if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
  2481. 		    && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
  2482.  
  2483.             PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
  2484. 			                     "Filename '".$p_entry['filename']."' exists "
  2485. 								 ."and is write protected");
  2486.  
  2487.             return PclZip::errorCode();
  2488. 		    }
  2489.       }
  2490.  
  2491.             else if (filemtime($p_entry['filename']) > $p_entry['mtime'])
  2492.       {
  2493.                 if (   (isset($p_options[PCLZIP_OPT_REPLACE_NEWER]))
  2494. 		    && ($p_options[PCLZIP_OPT_REPLACE_NEWER]===true)) {
  2495. 	  	  }
  2496. 		    else {
  2497.             $p_entry['status'] = "newer_exist";
  2498.  
  2499.                                                 if (   (isset($p_options[PCLZIP_OPT_STOP_ON_ERROR]))
  2500. 		        && ($p_options[PCLZIP_OPT_STOP_ON_ERROR]===true)) {
  2501.  
  2502.                 PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL,
  2503. 			             "Newer version of '".$p_entry['filename']."' exists "
  2504. 					    ."and option PCLZIP_OPT_REPLACE_NEWER is not selected");
  2505.  
  2506.                 return PclZip::errorCode();
  2507. 		      }
  2508. 		    }
  2509.       }
  2510.       else {
  2511.       }
  2512.     }
  2513.  
  2514.         else {
  2515.       if ((($p_entry['external']&0x00000010)==0x00000010) || (substr($p_entry['filename'], -1) == '/'))
  2516.         $v_dir_to_check = $p_entry['filename'];
  2517.       else if (!strstr($p_entry['filename'], "/"))
  2518.         $v_dir_to_check = "";
  2519.       else
  2520.         $v_dir_to_check = dirname($p_entry['filename']);
  2521.  
  2522.         if (($v_result = $this->privDirCheck($v_dir_to_check, (($p_entry['external']&0x00000010)==0x00000010))) != 1) {
  2523.   
  2524.                     $p_entry['status'] = "path_creation_fail";
  2525.   
  2526.                               $v_result = 1;
  2527.         }
  2528.       }
  2529.     }
  2530.  
  2531.         if ($p_entry['status'] == 'ok') {
  2532.  
  2533.             if (!(($p_entry['external']&0x00000010)==0x00000010))
  2534.       {
  2535.                 if ($p_entry['compression'] == 0) {
  2536.  
  2537.     		            if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0)
  2538.           {
  2539.  
  2540.                         $p_entry['status'] = "write_error";
  2541.  
  2542.                         return $v_result;
  2543.           }
  2544.  
  2545.  
  2546.                     $v_size = $p_entry['compressed_size'];
  2547.           while ($v_size != 0)
  2548.           {
  2549.             $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  2550.             $v_buffer = @fread($this->zip_fd, $v_read_size);
  2551.             @fwrite($v_dest_file, $v_buffer, $v_read_size);            
  2552.             $v_size -= $v_read_size;
  2553.           }
  2554.  
  2555.                     fclose($v_dest_file);
  2556.  
  2557.                     touch($p_entry['filename'], $p_entry['mtime']);
  2558.           
  2559.  
  2560.         }
  2561.         else {
  2562.                               if (($p_entry['flag'] & 1) == 1) {
  2563.             PclZip::privErrorLog(PCLZIP_ERR_UNSUPPORTED_ENCRYPTION, 'File \''.$p_entry['filename'].'\' is encrypted. Encrypted files are not supported.');
  2564.             return PclZip::errorCode();
  2565.           }
  2566.  
  2567.  
  2568.                     if ( (!isset($p_options[PCLZIP_OPT_TEMP_FILE_OFF])) 
  2569.               && (isset($p_options[PCLZIP_OPT_TEMP_FILE_ON])
  2570.                   || (isset($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD])
  2571.                       && ($p_options[PCLZIP_OPT_TEMP_FILE_THRESHOLD] <= $p_entry['size'])) ) ) {
  2572.             $v_result = $this->privExtractFileUsingTempFile($p_entry, $p_options);
  2573.             if ($v_result < PCLZIP_ERR_NO_ERROR) {
  2574.               return $v_result;
  2575.             }
  2576.           }
  2577.           
  2578.                     else {
  2579.  
  2580.           
  2581.                         $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
  2582.             
  2583.                         $v_file_content = @gzinflate($v_buffer);
  2584.             unset($v_buffer);
  2585.             if ($v_file_content === FALSE) {
  2586.   
  2587.                                           $p_entry['status'] = "error";
  2588.               
  2589.               return $v_result;
  2590.             }
  2591.             
  2592.                         if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
  2593.   
  2594.                             $p_entry['status'] = "write_error";
  2595.   
  2596.               return $v_result;
  2597.             }
  2598.   
  2599.                         @fwrite($v_dest_file, $v_file_content, $p_entry['size']);
  2600.             unset($v_file_content);
  2601.   
  2602.                         @fclose($v_dest_file);
  2603.             
  2604.           }
  2605.  
  2606.                     @touch($p_entry['filename'], $p_entry['mtime']);
  2607.         }
  2608.  
  2609.                 if (isset($p_options[PCLZIP_OPT_SET_CHMOD])) {
  2610.  
  2611.                     @chmod($p_entry['filename'], $p_options[PCLZIP_OPT_SET_CHMOD]);
  2612.         }
  2613.  
  2614.       }
  2615.     }
  2616.  
  2617.   	  	if ($p_entry['status'] == "aborted") {
  2618.         $p_entry['status'] = "skipped";
  2619.   	}
  2620. 	
  2621.         elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
  2622.  
  2623.             $v_local_header = array();
  2624.       $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
  2625.  
  2626.                         $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
  2627.  
  2628.             if ($v_result == 2) {
  2629.       	$v_result = PCLZIP_ERR_USER_ABORTED;
  2630.       }
  2631.     }
  2632.  
  2633.         return $v_result;
  2634.   }
  2635.   
  2636.               function privExtractFileUsingTempFile(&$p_entry, &$p_options)
  2637.   {
  2638.     $v_result=1;
  2639.         
  2640.         $v_gzip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.gz';
  2641.     if (($v_dest_file = @fopen($v_gzip_temp_name, "wb")) == 0) {
  2642.       fclose($v_file);
  2643.       PclZip::privErrorLog(PCLZIP_ERR_WRITE_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary write mode');
  2644.       return PclZip::errorCode();
  2645.     }
  2646.  
  2647.  
  2648.         $v_binary_data = pack('va1a1Va1a1', 0x8b1f, Chr($p_entry['compression']), Chr(0x00), time(), Chr(0x00), Chr(3));
  2649.     @fwrite($v_dest_file, $v_binary_data, 10);
  2650.  
  2651.         $v_size = $p_entry['compressed_size'];
  2652.     while ($v_size != 0)
  2653.     {
  2654.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  2655.       $v_buffer = @fread($this->zip_fd, $v_read_size);
  2656.             @fwrite($v_dest_file, $v_buffer, $v_read_size);
  2657.       $v_size -= $v_read_size;
  2658.     }
  2659.  
  2660.         $v_binary_data = pack('VV', $p_entry['crc'], $p_entry['size']);
  2661.     @fwrite($v_dest_file, $v_binary_data, 8);
  2662.  
  2663.         @fclose($v_dest_file);
  2664.  
  2665.         if (($v_dest_file = @fopen($p_entry['filename'], 'wb')) == 0) {
  2666.       $p_entry['status'] = "write_error";
  2667.       return $v_result;
  2668.     }
  2669.  
  2670.         if (($v_src_file = @gzopen($v_gzip_temp_name, 'rb')) == 0) {
  2671.       @fclose($v_dest_file);
  2672.       $p_entry['status'] = "read_error";
  2673.       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_gzip_temp_name.'\' in binary read mode');
  2674.       return PclZip::errorCode();
  2675.     }
  2676.  
  2677.  
  2678.         $v_size = $p_entry['size'];
  2679.     while ($v_size != 0) {
  2680.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  2681.       $v_buffer = @gzread($v_src_file, $v_read_size);
  2682.             @fwrite($v_dest_file, $v_buffer, $v_read_size);
  2683.       $v_size -= $v_read_size;
  2684.     }
  2685.     @fclose($v_dest_file);
  2686.     @gzclose($v_src_file);
  2687.  
  2688.         @unlink($v_gzip_temp_name);
  2689.     
  2690.         return $v_result;
  2691.   }
  2692.   
  2693.               function privExtractFileInOutput(&$p_entry, &$p_options)
  2694.   {
  2695.     $v_result=1;
  2696.  
  2697.         if (($v_result = $this->privReadFileHeader($v_header)) != 1) {
  2698.       return $v_result;
  2699.     }
  2700.  
  2701.  
  2702.         if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
  2703.             }
  2704.  
  2705.         if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
  2706.  
  2707.             $v_local_header = array();
  2708.       $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
  2709.  
  2710.                         $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
  2711.       if ($v_result == 0) {
  2712.                 $p_entry['status'] = "skipped";
  2713.         $v_result = 1;
  2714.       }
  2715.  
  2716.             if ($v_result == 2) {
  2717.                 $p_entry['status'] = "aborted";
  2718.       	$v_result = PCLZIP_ERR_USER_ABORTED;
  2719.       }
  2720.  
  2721.                   $p_entry['filename'] = $v_local_header['filename'];
  2722.     }
  2723.  
  2724.     
  2725.         if ($p_entry['status'] == 'ok') {
  2726.  
  2727.             if (!(($p_entry['external']&0x00000010)==0x00000010)) {
  2728.                 if ($p_entry['compressed_size'] == $p_entry['size']) {
  2729.  
  2730.                     $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
  2731.  
  2732.                     echo $v_buffer;
  2733.           unset($v_buffer);
  2734.         }
  2735.         else {
  2736.  
  2737.                     $v_buffer = @fread($this->zip_fd, $p_entry['compressed_size']);
  2738.           
  2739.                     $v_file_content = gzinflate($v_buffer);
  2740.           unset($v_buffer);
  2741.  
  2742.                     echo $v_file_content;
  2743.           unset($v_file_content);
  2744.         }
  2745.       }
  2746.     }
  2747.  
  2748. 		if ($p_entry['status'] == "aborted") {
  2749.       $p_entry['status'] = "skipped";
  2750. 	}
  2751.  
  2752.         elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
  2753.  
  2754.             $v_local_header = array();
  2755.       $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
  2756.  
  2757.                         $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
  2758.  
  2759.             if ($v_result == 2) {
  2760.       	$v_result = PCLZIP_ERR_USER_ABORTED;
  2761.       }
  2762.     }
  2763.  
  2764.     return $v_result;
  2765.   }
  2766.   
  2767.               function privExtractFileAsString(&$p_entry, &$p_string, &$p_options)
  2768.   {
  2769.     $v_result=1;
  2770.  
  2771.         $v_header = array();
  2772.     if (($v_result = $this->privReadFileHeader($v_header)) != 1)
  2773.     {
  2774.             return $v_result;
  2775.     }
  2776.  
  2777.  
  2778.         if ($this->privCheckFileHeaders($v_header, $p_entry) != 1) {
  2779.             }
  2780.  
  2781.         if (isset($p_options[PCLZIP_CB_PRE_EXTRACT])) {
  2782.  
  2783.             $v_local_header = array();
  2784.       $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
  2785.  
  2786.                         $v_result = $p_options[PCLZIP_CB_PRE_EXTRACT](PCLZIP_CB_PRE_EXTRACT, $v_local_header);
  2787.       if ($v_result == 0) {
  2788.                 $p_entry['status'] = "skipped";
  2789.         $v_result = 1;
  2790.       }
  2791.       
  2792.             if ($v_result == 2) {
  2793.                 $p_entry['status'] = "aborted";
  2794.       	$v_result = PCLZIP_ERR_USER_ABORTED;
  2795.       }
  2796.  
  2797.                   $p_entry['filename'] = $v_local_header['filename'];
  2798.     }
  2799.  
  2800.  
  2801.         if ($p_entry['status'] == 'ok') {
  2802.  
  2803.             if (!(($p_entry['external']&0x00000010)==0x00000010)) {
  2804.                   if ($p_entry['compression'] == 0) {
  2805.   
  2806.                     $p_string = @fread($this->zip_fd, $p_entry['compressed_size']);
  2807.         }
  2808.         else {
  2809.   
  2810.                     $v_data = @fread($this->zip_fd, $p_entry['compressed_size']);
  2811.           
  2812.                     if (($p_string = @gzinflate($v_data)) === FALSE) {
  2813.                         }
  2814.         }
  2815.   
  2816.               }
  2817.       else {
  2818.                 }
  2819.       
  2820.     }
  2821.  
  2822.   	  	if ($p_entry['status'] == "aborted") {
  2823.         $p_entry['status'] = "skipped";
  2824.   	}
  2825. 	
  2826.         elseif (isset($p_options[PCLZIP_CB_POST_EXTRACT])) {
  2827.  
  2828.             $v_local_header = array();
  2829.       $this->privConvertHeader2FileInfo($p_entry, $v_local_header);
  2830.       
  2831.             $v_local_header['content'] = $p_string;
  2832.       $p_string = '';
  2833.  
  2834.                         $v_result = $p_options[PCLZIP_CB_POST_EXTRACT](PCLZIP_CB_POST_EXTRACT, $v_local_header);
  2835.  
  2836.             $p_string = $v_local_header['content'];
  2837.       unset($v_local_header['content']);
  2838.  
  2839.             if ($v_result == 2) {
  2840.       	$v_result = PCLZIP_ERR_USER_ABORTED;
  2841.       }
  2842.     }
  2843.  
  2844.         return $v_result;
  2845.   }
  2846.   
  2847.               function privReadFileHeader(&$p_header)
  2848.   {
  2849.     $v_result=1;
  2850.  
  2851.         $v_binary_data = @fread($this->zip_fd, 4);
  2852.     $v_data = unpack('Vid', $v_binary_data);
  2853.  
  2854.         if ($v_data['id'] != 0x04034b50)
  2855.     {
  2856.  
  2857.             PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
  2858.  
  2859.             return PclZip::errorCode();
  2860.     }
  2861.  
  2862.         $v_binary_data = fread($this->zip_fd, 26);
  2863.  
  2864.         if (strlen($v_binary_data) != 26)
  2865.     {
  2866.       $p_header['filename'] = "";
  2867.       $p_header['status'] = "invalid_header";
  2868.  
  2869.             PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
  2870.  
  2871.             return PclZip::errorCode();
  2872.     }
  2873.  
  2874.         $v_data = unpack('vversion/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len', $v_binary_data);
  2875.  
  2876.         $p_header['filename'] = fread($this->zip_fd, $v_data['filename_len']);
  2877.  
  2878.         if ($v_data['extra_len'] != 0) {
  2879.       $p_header['extra'] = fread($this->zip_fd, $v_data['extra_len']);
  2880.     }
  2881.     else {
  2882.       $p_header['extra'] = '';
  2883.     }
  2884.  
  2885.         $p_header['version_extracted'] = $v_data['version'];
  2886.     $p_header['compression'] = $v_data['compression'];
  2887.     $p_header['size'] = $v_data['size'];
  2888.     $p_header['compressed_size'] = $v_data['compressed_size'];
  2889.     $p_header['crc'] = $v_data['crc'];
  2890.     $p_header['flag'] = $v_data['flag'];
  2891.     $p_header['filename_len'] = $v_data['filename_len'];
  2892.  
  2893.         $p_header['mdate'] = $v_data['mdate'];
  2894.     $p_header['mtime'] = $v_data['mtime'];
  2895.     if ($p_header['mdate'] && $p_header['mtime'])
  2896.     {
  2897.             $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
  2898.       $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
  2899.       $v_seconde = ($p_header['mtime'] & 0x001F)*2;
  2900.  
  2901.             $v_year = (($p_header['mdate'] & 0xFE00) >> 9) + 1980;
  2902.       $v_month = ($p_header['mdate'] & 0x01E0) >> 5;
  2903.       $v_day = $p_header['mdate'] & 0x001F;
  2904.  
  2905.             $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
  2906.  
  2907.     }
  2908.     else
  2909.     {
  2910.       $p_header['mtime'] = time();
  2911.     }
  2912.  
  2913.             
  2914.         $p_header['stored_filename'] = $p_header['filename'];
  2915.  
  2916.         $p_header['status'] = "ok";
  2917.  
  2918.         return $v_result;
  2919.   }
  2920.   
  2921.               function privReadCentralFileHeader(&$p_header)
  2922.   {
  2923.     $v_result=1;
  2924.  
  2925.         $v_binary_data = @fread($this->zip_fd, 4);
  2926.     $v_data = unpack('Vid', $v_binary_data);
  2927.  
  2928.         if ($v_data['id'] != 0x02014b50)
  2929.     {
  2930.  
  2931.             PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Invalid archive structure');
  2932.  
  2933.             return PclZip::errorCode();
  2934.     }
  2935.  
  2936.         $v_binary_data = fread($this->zip_fd, 42);
  2937.  
  2938.         if (strlen($v_binary_data) != 42)
  2939.     {
  2940.       $p_header['filename'] = "";
  2941.       $p_header['status'] = "invalid_header";
  2942.  
  2943.             PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid block size : ".strlen($v_binary_data));
  2944.  
  2945.             return PclZip::errorCode();
  2946.     }
  2947.  
  2948.         $p_header = unpack('vversion/vversion_extracted/vflag/vcompression/vmtime/vmdate/Vcrc/Vcompressed_size/Vsize/vfilename_len/vextra_len/vcomment_len/vdisk/vinternal/Vexternal/Voffset', $v_binary_data);
  2949.  
  2950.         if ($p_header['filename_len'] != 0)
  2951.       $p_header['filename'] = fread($this->zip_fd, $p_header['filename_len']);
  2952.     else
  2953.       $p_header['filename'] = '';
  2954.  
  2955.         if ($p_header['extra_len'] != 0)
  2956.       $p_header['extra'] = fread($this->zip_fd, $p_header['extra_len']);
  2957.     else
  2958.       $p_header['extra'] = '';
  2959.  
  2960.         if ($p_header['comment_len'] != 0)
  2961.       $p_header['comment'] = fread($this->zip_fd, $p_header['comment_len']);
  2962.     else
  2963.       $p_header['comment'] = '';
  2964.  
  2965.     
  2966.                 if (1)
  2967.     {
  2968.             $v_hour = ($p_header['mtime'] & 0xF800) >> 11;
  2969.       $v_minute = ($p_header['mtime'] & 0x07E0) >> 5;
  2970.       $v_seconde = ($p_header['mtime'] & 0x001F)*2;
  2971.  
  2972.             $v_year = (($p_header['mdate'] & 0xFE00) >> 9) + 1980;
  2973.       $v_month = ($p_header['mdate'] & 0x01E0) >> 5;
  2974.       $v_day = $p_header['mdate'] & 0x001F;
  2975.  
  2976.             $p_header['mtime'] = @mktime($v_hour, $v_minute, $v_seconde, $v_month, $v_day, $v_year);
  2977.  
  2978.     }
  2979.     else
  2980.     {
  2981.       $p_header['mtime'] = time();
  2982.     }
  2983.  
  2984.         $p_header['stored_filename'] = $p_header['filename'];
  2985.  
  2986.         $p_header['status'] = 'ok';
  2987.  
  2988.         if (substr($p_header['filename'], -1) == '/') {
  2989.             $p_header['external'] = 0x00000010;
  2990.     }
  2991.  
  2992.  
  2993.         return $v_result;
  2994.   }
  2995.   
  2996.                   function privCheckFileHeaders(&$p_local_header, &$p_central_header)
  2997.   {
  2998.     $v_result=1;
  2999.  
  3000.   	  	  	if ($p_local_header['filename'] != $p_central_header['filename']) {
  3001.   	}
  3002.   	if ($p_local_header['version_extracted'] != $p_central_header['version_extracted']) {
  3003.   	}
  3004.   	if ($p_local_header['flag'] != $p_central_header['flag']) {
  3005.   	}
  3006.   	if ($p_local_header['compression'] != $p_central_header['compression']) {
  3007.   	}
  3008.   	if ($p_local_header['mtime'] != $p_central_header['mtime']) {
  3009.   	}
  3010.   	if ($p_local_header['filename_len'] != $p_central_header['filename_len']) {
  3011.   	}
  3012.   
  3013.   	  	if (($p_local_header['flag'] & 8) == 8) {
  3014.           $p_local_header['size'] = $p_central_header['size'];
  3015.           $p_local_header['compressed_size'] = $p_central_header['compressed_size'];
  3016.           $p_local_header['crc'] = $p_central_header['crc'];
  3017.   	}
  3018.  
  3019.         return $v_result;
  3020.   }
  3021.   
  3022.               function privReadEndCentralDir(&$p_central_dir)
  3023.   {
  3024.     $v_result=1;
  3025.  
  3026.         $v_size = filesize($this->zipname);
  3027.     @fseek($this->zip_fd, $v_size);
  3028.     if (@ftell($this->zip_fd) != $v_size)
  3029.     {
  3030.             PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to go to the end of the archive \''.$this->zipname.'\'');
  3031.  
  3032.             return PclZip::errorCode();
  3033.     }
  3034.  
  3035.             $v_found = 0;
  3036.     if ($v_size > 26) {
  3037.       @fseek($this->zip_fd, $v_size-22);
  3038.       if (($v_pos = @ftell($this->zip_fd)) != ($v_size-22))
  3039.       {
  3040.                 PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
  3041.  
  3042.                 return PclZip::errorCode();
  3043.       }
  3044.  
  3045.             $v_binary_data = @fread($this->zip_fd, 4);
  3046.       $v_data = @unpack('Vid', $v_binary_data);
  3047.  
  3048.             if ($v_data['id'] == 0x06054b50) {
  3049.         $v_found = 1;
  3050.       }
  3051.  
  3052.       $v_pos = ftell($this->zip_fd);
  3053.     }
  3054.  
  3055.         if (!$v_found) {
  3056.       $v_maximum_size = 65557;       if ($v_maximum_size > $v_size)
  3057.         $v_maximum_size = $v_size;
  3058.       @fseek($this->zip_fd, $v_size-$v_maximum_size);
  3059.       if (@ftell($this->zip_fd) != ($v_size-$v_maximum_size))
  3060.       {
  3061.                 PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, 'Unable to seek back to the middle of the archive \''.$this->zipname.'\'');
  3062.  
  3063.                 return PclZip::errorCode();
  3064.       }
  3065.  
  3066.             $v_pos = ftell($this->zip_fd);
  3067.       $v_bytes = 0x00000000;
  3068.       while ($v_pos < $v_size)
  3069.       {
  3070.                 $v_byte = @fread($this->zip_fd, 1);
  3071.  
  3072.                                         $v_bytes = ( ($v_bytes & 0xFFFFFF) << 8) | Ord($v_byte); 
  3073.  
  3074.                 if ($v_bytes == 0x504b0506)
  3075.         {
  3076.           $v_pos++;
  3077.           break;
  3078.         }
  3079.  
  3080.         $v_pos++;
  3081.       }
  3082.  
  3083.             if ($v_pos == $v_size)
  3084.       {
  3085.  
  3086.                 PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Unable to find End of Central Dir Record signature");
  3087.  
  3088.                 return PclZip::errorCode();
  3089.       }
  3090.     }
  3091.  
  3092.         $v_binary_data = fread($this->zip_fd, 18);
  3093.  
  3094.         if (strlen($v_binary_data) != 18)
  3095.     {
  3096.  
  3097.             PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT, "Invalid End of Central Dir Record size : ".strlen($v_binary_data));
  3098.  
  3099.             return PclZip::errorCode();
  3100.     }
  3101.  
  3102.         $v_data = unpack('vdisk/vdisk_start/vdisk_entries/ventries/Vsize/Voffset/vcomment_size', $v_binary_data);
  3103.  
  3104.         if (($v_pos + $v_data['comment_size'] + 18) != $v_size) {
  3105.  
  3106. 	  	  	  	  	  if (0) {
  3107.             PclZip::privErrorLog(PCLZIP_ERR_BAD_FORMAT,
  3108. 	                       'The central dir is not at the end of the archive.'
  3109. 						   .' Some trailing bytes exists after the archive.');
  3110.  
  3111.             return PclZip::errorCode();
  3112. 	  }
  3113.     }
  3114.  
  3115.         if ($v_data['comment_size'] != 0) {
  3116.       $p_central_dir['comment'] = fread($this->zip_fd, $v_data['comment_size']);
  3117.     }
  3118.     else
  3119.       $p_central_dir['comment'] = '';
  3120.  
  3121.     $p_central_dir['entries'] = $v_data['entries'];
  3122.     $p_central_dir['disk_entries'] = $v_data['disk_entries'];
  3123.     $p_central_dir['offset'] = $v_data['offset'];
  3124.     $p_central_dir['size'] = $v_data['size'];
  3125.     $p_central_dir['disk'] = $v_data['disk'];
  3126.     $p_central_dir['disk_start'] = $v_data['disk_start'];
  3127.  
  3128.             
  3129.         return $v_result;
  3130.   }
  3131.   
  3132.               function privDeleteByRule(&$p_result_list, &$p_options)
  3133.   {
  3134.     $v_result=1;
  3135.     $v_list_detail = array();
  3136.  
  3137.         if (($v_result=$this->privOpenFd('rb')) != 1)
  3138.     {
  3139.             return $v_result;
  3140.     }
  3141.  
  3142.         $v_central_dir = array();
  3143.     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
  3144.     {
  3145.       $this->privCloseFd();
  3146.       return $v_result;
  3147.     }
  3148.  
  3149.         @rewind($this->zip_fd);
  3150.  
  3151.             $v_pos_entry = $v_central_dir['offset'];
  3152.     @rewind($this->zip_fd);
  3153.     if (@fseek($this->zip_fd, $v_pos_entry))
  3154.     {
  3155.             $this->privCloseFd();
  3156.  
  3157.             PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
  3158.  
  3159.             return PclZip::errorCode();
  3160.     }
  3161.  
  3162.         $v_header_list = array();
  3163.     $j_start = 0;
  3164.     for ($i=0, $v_nb_extracted=0; $i<$v_central_dir['entries']; $i++)
  3165.     {
  3166.  
  3167.             $v_header_list[$v_nb_extracted] = array();
  3168.       if (($v_result = $this->privReadCentralFileHeader($v_header_list[$v_nb_extracted])) != 1)
  3169.       {
  3170.                 $this->privCloseFd();
  3171.  
  3172.         return $v_result;
  3173.       }
  3174.  
  3175.  
  3176.             $v_header_list[$v_nb_extracted]['index'] = $i;
  3177.  
  3178.             $v_found = false;
  3179.  
  3180.             if (   (isset($p_options[PCLZIP_OPT_BY_NAME]))
  3181.           && ($p_options[PCLZIP_OPT_BY_NAME] != 0)) {
  3182.  
  3183.                     for ($j=0; ($j<sizeof($p_options[PCLZIP_OPT_BY_NAME])) && (!$v_found); $j++) {
  3184.  
  3185.                             if (substr($p_options[PCLZIP_OPT_BY_NAME][$j], -1) == "/") {
  3186.  
  3187.                                     if (   (strlen($v_header_list[$v_nb_extracted]['stored_filename']) > strlen($p_options[PCLZIP_OPT_BY_NAME][$j]))
  3188.                       && (substr($v_header_list[$v_nb_extracted]['stored_filename'], 0, strlen($p_options[PCLZIP_OPT_BY_NAME][$j])) == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
  3189.                       $v_found = true;
  3190.                   }
  3191.                   elseif (   (($v_header_list[$v_nb_extracted]['external']&0x00000010)==0x00000010)
  3192.                           && ($v_header_list[$v_nb_extracted]['stored_filename'].'/' == $p_options[PCLZIP_OPT_BY_NAME][$j])) {
  3193.                       $v_found = true;
  3194.                   }
  3195.               }
  3196.                             elseif ($v_header_list[$v_nb_extracted]['stored_filename'] == $p_options[PCLZIP_OPT_BY_NAME][$j]) {
  3197.                   $v_found = true;
  3198.               }
  3199.           }
  3200.       }
  3201.  
  3202.             else if (   (isset($p_options[PCLZIP_OPT_BY_PREG]))
  3203.                && ($p_options[PCLZIP_OPT_BY_PREG] != "")) {
  3204.  
  3205.           if (preg_match($p_options[PCLZIP_OPT_BY_PREG], $v_header_list[$v_nb_extracted]['stored_filename'])) {
  3206.               $v_found = true;
  3207.           }
  3208.       }
  3209.  
  3210.             else if (   (isset($p_options[PCLZIP_OPT_BY_INDEX]))
  3211.                && ($p_options[PCLZIP_OPT_BY_INDEX] != 0)) {
  3212.  
  3213.                     for ($j=$j_start; ($j<sizeof($p_options[PCLZIP_OPT_BY_INDEX])) && (!$v_found); $j++) {
  3214.  
  3215.               if (($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['start']) && ($i<=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end'])) {
  3216.                   $v_found = true;
  3217.               }
  3218.               if ($i>=$p_options[PCLZIP_OPT_BY_INDEX][$j]['end']) {
  3219.                   $j_start = $j+1;
  3220.               }
  3221.  
  3222.               if ($p_options[PCLZIP_OPT_BY_INDEX][$j]['start']>$i) {
  3223.                   break;
  3224.               }
  3225.           }
  3226.       }
  3227.       else {
  3228.       	$v_found = true;
  3229.       }
  3230.  
  3231.             if ($v_found)
  3232.       {
  3233.         unset($v_header_list[$v_nb_extracted]);
  3234.       }
  3235.       else
  3236.       {
  3237.         $v_nb_extracted++;
  3238.       }
  3239.     }
  3240.  
  3241.         if ($v_nb_extracted > 0) {
  3242.  
  3243.                 $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
  3244.  
  3245.                 $v_temp_zip = new PclZip($v_zip_temp_name);
  3246.  
  3247.                 if (($v_result = $v_temp_zip->privOpenFd('wb')) != 1) {
  3248.             $this->privCloseFd();
  3249.  
  3250.                         return $v_result;
  3251.         }
  3252.  
  3253.                 for ($i=0; $i<sizeof($v_header_list); $i++) {
  3254.  
  3255.                         @rewind($this->zip_fd);
  3256.             if (@fseek($this->zip_fd,  $v_header_list[$i]['offset'])) {
  3257.                                 $this->privCloseFd();
  3258.                 $v_temp_zip->privCloseFd();
  3259.                 @unlink($v_zip_temp_name);
  3260.  
  3261.                                 PclZip::privErrorLog(PCLZIP_ERR_INVALID_ARCHIVE_ZIP, 'Invalid archive size');
  3262.  
  3263.                                 return PclZip::errorCode();
  3264.             }
  3265.  
  3266.                         $v_local_header = array();
  3267.             if (($v_result = $this->privReadFileHeader($v_local_header)) != 1) {
  3268.                                 $this->privCloseFd();
  3269.                 $v_temp_zip->privCloseFd();
  3270.                 @unlink($v_zip_temp_name);
  3271.  
  3272.                                 return $v_result;
  3273.             }
  3274.             
  3275.                         if ($this->privCheckFileHeaders($v_local_header,
  3276. 			                                $v_header_list[$i]) != 1) {
  3277.                             }
  3278.             unset($v_local_header);
  3279.  
  3280.                         if (($v_result = $v_temp_zip->privWriteFileHeader($v_header_list[$i])) != 1) {
  3281.                                 $this->privCloseFd();
  3282.                 $v_temp_zip->privCloseFd();
  3283.                 @unlink($v_zip_temp_name);
  3284.  
  3285.                                 return $v_result;
  3286.             }
  3287.  
  3288.                         if (($v_result = PclZipUtilCopyBlock($this->zip_fd, $v_temp_zip->zip_fd, $v_header_list[$i]['compressed_size'])) != 1) {
  3289.                                 $this->privCloseFd();
  3290.                 $v_temp_zip->privCloseFd();
  3291.                 @unlink($v_zip_temp_name);
  3292.  
  3293.                                 return $v_result;
  3294.             }
  3295.         }
  3296.  
  3297.                 $v_offset = @ftell($v_temp_zip->zip_fd);
  3298.  
  3299.                 for ($i=0; $i<sizeof($v_header_list); $i++) {
  3300.                         if (($v_result = $v_temp_zip->privWriteCentralFileHeader($v_header_list[$i])) != 1) {
  3301.                 $v_temp_zip->privCloseFd();
  3302.                 $this->privCloseFd();
  3303.                 @unlink($v_zip_temp_name);
  3304.  
  3305.                                 return $v_result;
  3306.             }
  3307.  
  3308.                         $v_temp_zip->privConvertHeader2FileInfo($v_header_list[$i], $p_result_list[$i]);
  3309.         }
  3310.  
  3311.  
  3312.                 $v_comment = '';
  3313.         if (isset($p_options[PCLZIP_OPT_COMMENT])) {
  3314.           $v_comment = $p_options[PCLZIP_OPT_COMMENT];
  3315.         }
  3316.  
  3317.                 $v_size = @ftell($v_temp_zip->zip_fd)-$v_offset;
  3318.  
  3319.                 if (($v_result = $v_temp_zip->privWriteCentralHeader(sizeof($v_header_list), $v_size, $v_offset, $v_comment)) != 1) {
  3320.                         unset($v_header_list);
  3321.             $v_temp_zip->privCloseFd();
  3322.             $this->privCloseFd();
  3323.             @unlink($v_zip_temp_name);
  3324.  
  3325.                         return $v_result;
  3326.         }
  3327.  
  3328.                 $v_temp_zip->privCloseFd();
  3329.         $this->privCloseFd();
  3330.  
  3331.                         @unlink($this->zipname);
  3332.  
  3333.                                 PclZipUtilRename($v_zip_temp_name, $this->zipname);
  3334.     
  3335.                 unset($v_temp_zip);
  3336.     }
  3337.     
  3338.         else if ($v_central_dir['entries'] != 0) {
  3339.         $this->privCloseFd();
  3340.  
  3341.         if (($v_result = $this->privOpenFd('wb')) != 1) {
  3342.           return $v_result;
  3343.         }
  3344.  
  3345.         if (($v_result = $this->privWriteCentralHeader(0, 0, 0, '')) != 1) {
  3346.           return $v_result;
  3347.         }
  3348.  
  3349.         $this->privCloseFd();
  3350.     }
  3351.  
  3352.         return $v_result;
  3353.   }
  3354.   
  3355.                         function privDirCheck($p_dir, $p_is_dir=false)
  3356.   {
  3357.     $v_result = 1;
  3358.  
  3359.  
  3360.         if (($p_is_dir) && (substr($p_dir, -1)=='/'))
  3361.     {
  3362.       $p_dir = substr($p_dir, 0, strlen($p_dir)-1);
  3363.     }
  3364.  
  3365.         if ((is_dir($p_dir)) || ($p_dir == ""))
  3366.     {
  3367.       return 1;
  3368.     }
  3369.  
  3370.         $p_parent_dir = dirname($p_dir);
  3371.  
  3372.         if ($p_parent_dir != $p_dir)
  3373.     {
  3374.             if ($p_parent_dir != "")
  3375.       {
  3376.         if (($v_result = $this->privDirCheck($p_parent_dir)) != 1)
  3377.         {
  3378.           return $v_result;
  3379.         }
  3380.       }
  3381.     }
  3382.  
  3383.         if (!@mkdir($p_dir, 0777))
  3384.     {
  3385.             PclZip::privErrorLog(PCLZIP_ERR_DIR_CREATE_FAIL, "Unable to create directory '$p_dir'");
  3386.  
  3387.             return PclZip::errorCode();
  3388.     }
  3389.  
  3390.         return $v_result;
  3391.   }
  3392.   
  3393.                 function privMerge(&$p_archive_to_add)
  3394.   {
  3395.     $v_result=1;
  3396.  
  3397.         if (!is_file($p_archive_to_add->zipname))
  3398.     {
  3399.  
  3400.             $v_result = 1;
  3401.  
  3402.             return $v_result;
  3403.     }
  3404.  
  3405.         if (!is_file($this->zipname))
  3406.     {
  3407.  
  3408.             $v_result = $this->privDuplicate($p_archive_to_add->zipname);
  3409.  
  3410.             return $v_result;
  3411.     }
  3412.  
  3413.         if (($v_result=$this->privOpenFd('rb')) != 1)
  3414.     {
  3415.             return $v_result;
  3416.     }
  3417.  
  3418.         $v_central_dir = array();
  3419.     if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)
  3420.     {
  3421.       $this->privCloseFd();
  3422.       return $v_result;
  3423.     }
  3424.  
  3425.         @rewind($this->zip_fd);
  3426.  
  3427.         if (($v_result=$p_archive_to_add->privOpenFd('rb')) != 1)
  3428.     {
  3429.       $this->privCloseFd();
  3430.  
  3431.             return $v_result;
  3432.     }
  3433.  
  3434.         $v_central_dir_to_add = array();
  3435.     if (($v_result = $p_archive_to_add->privReadEndCentralDir($v_central_dir_to_add)) != 1)
  3436.     {
  3437.       $this->privCloseFd();
  3438.       $p_archive_to_add->privCloseFd();
  3439.  
  3440.       return $v_result;
  3441.     }
  3442.  
  3443.         @rewind($p_archive_to_add->zip_fd);
  3444.  
  3445.         $v_zip_temp_name = PCLZIP_TEMPORARY_DIR.uniqid('pclzip-').'.tmp';
  3446.  
  3447.         if (($v_zip_temp_fd = @fopen($v_zip_temp_name, 'wb')) == 0)
  3448.     {
  3449.       $this->privCloseFd();
  3450.       $p_archive_to_add->privCloseFd();
  3451.  
  3452.       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open temporary file \''.$v_zip_temp_name.'\' in binary write mode');
  3453.  
  3454.             return PclZip::errorCode();
  3455.     }
  3456.  
  3457.             $v_size = $v_central_dir['offset'];
  3458.     while ($v_size != 0)
  3459.     {
  3460.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  3461.       $v_buffer = fread($this->zip_fd, $v_read_size);
  3462.       @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
  3463.       $v_size -= $v_read_size;
  3464.     }
  3465.  
  3466.         $v_size = $v_central_dir_to_add['offset'];
  3467.     while ($v_size != 0)
  3468.     {
  3469.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  3470.       $v_buffer = fread($p_archive_to_add->zip_fd, $v_read_size);
  3471.       @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
  3472.       $v_size -= $v_read_size;
  3473.     }
  3474.  
  3475.         $v_offset = @ftell($v_zip_temp_fd);
  3476.  
  3477.         $v_size = $v_central_dir['size'];
  3478.     while ($v_size != 0)
  3479.     {
  3480.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  3481.       $v_buffer = @fread($this->zip_fd, $v_read_size);
  3482.       @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
  3483.       $v_size -= $v_read_size;
  3484.     }
  3485.  
  3486.         $v_size = $v_central_dir_to_add['size'];
  3487.     while ($v_size != 0)
  3488.     {
  3489.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  3490.       $v_buffer = @fread($p_archive_to_add->zip_fd, $v_read_size);
  3491.       @fwrite($v_zip_temp_fd, $v_buffer, $v_read_size);
  3492.       $v_size -= $v_read_size;
  3493.     }
  3494.  
  3495.         $v_comment = $v_central_dir['comment'].' '.$v_central_dir_to_add['comment'];
  3496.  
  3497.         $v_size = @ftell($v_zip_temp_fd)-$v_offset;
  3498.  
  3499.                 $v_swap = $this->zip_fd;
  3500.     $this->zip_fd = $v_zip_temp_fd;
  3501.     $v_zip_temp_fd = $v_swap;
  3502.  
  3503.         if (($v_result = $this->privWriteCentralHeader($v_central_dir['entries']+$v_central_dir_to_add['entries'], $v_size, $v_offset, $v_comment)) != 1)
  3504.     {
  3505.       $this->privCloseFd();
  3506.       $p_archive_to_add->privCloseFd();
  3507.       @fclose($v_zip_temp_fd);
  3508.       $this->zip_fd = null;
  3509.  
  3510.             unset($v_header_list);
  3511.  
  3512.             return $v_result;
  3513.     }
  3514.  
  3515.         $v_swap = $this->zip_fd;
  3516.     $this->zip_fd = $v_zip_temp_fd;
  3517.     $v_zip_temp_fd = $v_swap;
  3518.  
  3519.         $this->privCloseFd();
  3520.     $p_archive_to_add->privCloseFd();
  3521.  
  3522.         @fclose($v_zip_temp_fd);
  3523.  
  3524.             @unlink($this->zipname);
  3525.  
  3526.                 PclZipUtilRename($v_zip_temp_name, $this->zipname);
  3527.  
  3528.         return $v_result;
  3529.   }
  3530.   
  3531.               function privDuplicate($p_archive_filename)
  3532.   {
  3533.     $v_result=1;
  3534.  
  3535.         if (!is_file($p_archive_filename))
  3536.     {
  3537.  
  3538.             $v_result = 1;
  3539.  
  3540.             return $v_result;
  3541.     }
  3542.  
  3543.         if (($v_result=$this->privOpenFd('wb')) != 1)
  3544.     {
  3545.             return $v_result;
  3546.     }
  3547.  
  3548.         if (($v_zip_temp_fd = @fopen($p_archive_filename, 'rb')) == 0)
  3549.     {
  3550.       $this->privCloseFd();
  3551.  
  3552.       PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive file \''.$p_archive_filename.'\' in binary write mode');
  3553.  
  3554.             return PclZip::errorCode();
  3555.     }
  3556.  
  3557.             $v_size = filesize($p_archive_filename);
  3558.     while ($v_size != 0)
  3559.     {
  3560.       $v_read_size = ($v_size < PCLZIP_READ_BLOCK_SIZE ? $v_size : PCLZIP_READ_BLOCK_SIZE);
  3561.       $v_buffer = fread($v_zip_temp_fd, $v_read_size);
  3562.       @fwrite($this->zip_fd, $v_buffer, $v_read_size);
  3563.       $v_size -= $v_read_size;
  3564.     }
  3565.  
  3566.         $this->privCloseFd();
  3567.  
  3568.         @fclose($v_zip_temp_fd);
  3569.  
  3570.         return $v_result;
  3571.   }
  3572.   
  3573.             function privErrorLog($p_error_code=0, $p_error_string='')
  3574.   {
  3575.     if (PCLZIP_ERROR_EXTERNAL == 1) {
  3576.       PclError($p_error_code, $p_error_string);
  3577.     }
  3578.     else {
  3579.       $this->error_code = $p_error_code;
  3580.       $this->error_string = $p_error_string;
  3581.     }
  3582.   }
  3583.   
  3584.             function privErrorReset()
  3585.   {
  3586.     if (PCLZIP_ERROR_EXTERNAL == 1) {
  3587.       PclErrorReset();
  3588.     }
  3589.     else {
  3590.       $this->error_code = 0;
  3591.       $this->error_string = '';
  3592.     }
  3593.   }
  3594.   
  3595.               function privDisableMagicQuotes()
  3596.   {
  3597.     $v_result=1;
  3598.  
  3599.         if (   (!function_exists("get_magic_quotes_runtime"))
  3600. 	    || (!function_exists("set_magic_quotes_runtime"))) {
  3601.       return $v_result;
  3602. 	}
  3603.  
  3604.         if ($this->magic_quotes_status != -1) {
  3605.       return $v_result;
  3606. 	}
  3607.  
  3608. 		$this->magic_quotes_status = @get_magic_quotes_runtime();
  3609.  
  3610. 		if ($this->magic_quotes_status == 1) {
  3611. 	  @set_magic_quotes_runtime(0);
  3612. 	}
  3613.  
  3614.         return $v_result;
  3615.   }
  3616.   
  3617.               function privSwapBackMagicQuotes()
  3618.   {
  3619.     $v_result=1;
  3620.  
  3621.         if (   (!function_exists("get_magic_quotes_runtime"))
  3622. 	    || (!function_exists("set_magic_quotes_runtime"))) {
  3623.       return $v_result;
  3624. 	}
  3625.  
  3626.         if ($this->magic_quotes_status != -1) {
  3627.       return $v_result;
  3628. 	}
  3629.  
  3630. 		if ($this->magic_quotes_status == 1) {
  3631.   	  @set_magic_quotes_runtime($this->magic_quotes_status);
  3632. 	}
  3633.  
  3634.         return $v_result;
  3635.   }
  3636.   
  3637.   }
  3638.     
  3639.               function PclZipUtilPathReduction($p_dir)
  3640.   {
  3641.     $v_result = "";
  3642.  
  3643.         if ($p_dir != "") {
  3644.             $v_list = explode("/", $p_dir);
  3645.  
  3646.             $v_skip = 0;
  3647.       for ($i=sizeof($v_list)-1; $i>=0; $i--) {
  3648.                 if ($v_list[$i] == ".") {
  3649.                             }
  3650.         else if ($v_list[$i] == "..") {
  3651. 		  $v_skip++;
  3652.         }
  3653.         else if ($v_list[$i] == "") {
  3654. 		  		  if ($i == 0) {
  3655.             $v_result = "/".$v_result;
  3656. 		    if ($v_skip > 0) {
  3657. 		        		        		        $v_result = $p_dir;
  3658.                 $v_skip = 0;
  3659. 		    }
  3660. 		  }
  3661. 		  		  else if ($i == (sizeof($v_list)-1)) {
  3662.             $v_result = $v_list[$i];
  3663. 		  }
  3664. 		  		  else {
  3665.                         		  }
  3666.         }
  3667.         else {
  3668. 		  		  if ($v_skip > 0) {
  3669. 		    $v_skip--;
  3670. 		  }
  3671. 		  else {
  3672.             $v_result = $v_list[$i].($i!=(sizeof($v_list)-1)?"/".$v_result:"");
  3673. 		  }
  3674.         }
  3675.       }
  3676.       
  3677.             if ($v_skip > 0) {
  3678.         while ($v_skip > 0) {
  3679.             $v_result = '../'.$v_result;
  3680.             $v_skip--;
  3681.         }
  3682.       }
  3683.     }
  3684.  
  3685.         return $v_result;
  3686.   }
  3687.   
  3688.                                 function PclZipUtilPathInclusion($p_dir, $p_path)
  3689.   {
  3690.     $v_result = 1;
  3691.     
  3692.         if (   ($p_dir == '.')
  3693.         || ((strlen($p_dir) >=2) && (substr($p_dir, 0, 2) == './'))) {
  3694.       $p_dir = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_dir, 1);
  3695.     }
  3696.     if (   ($p_path == '.')
  3697.         || ((strlen($p_path) >=2) && (substr($p_path, 0, 2) == './'))) {
  3698.       $p_path = PclZipUtilTranslateWinPath(getcwd(), FALSE).'/'.substr($p_path, 1);
  3699.     }
  3700.  
  3701.         $v_list_dir = explode("/", $p_dir);
  3702.     $v_list_dir_size = sizeof($v_list_dir);
  3703.     $v_list_path = explode("/", $p_path);
  3704.     $v_list_path_size = sizeof($v_list_path);
  3705.  
  3706.         $i = 0;
  3707.     $j = 0;
  3708.     while (($i < $v_list_dir_size) && ($j < $v_list_path_size) && ($v_result)) {
  3709.  
  3710.             if ($v_list_dir[$i] == '') {
  3711.         $i++;
  3712.         continue;
  3713.       }
  3714.       if ($v_list_path[$j] == '') {
  3715.         $j++;
  3716.         continue;
  3717.       }
  3718.  
  3719.             if (($v_list_dir[$i] != $v_list_path[$j]) && ($v_list_dir[$i] != '') && ( $v_list_path[$j] != ''))  {
  3720.         $v_result = 0;
  3721.       }
  3722.  
  3723.             $i++;
  3724.       $j++;
  3725.     }
  3726.  
  3727.         if ($v_result) {
  3728.             while (($j < $v_list_path_size) && ($v_list_path[$j] == '')) $j++;
  3729.       while (($i < $v_list_dir_size) && ($v_list_dir[$i] == '')) $i++;
  3730.  
  3731.       if (($i >= $v_list_dir_size) && ($j >= $v_list_path_size)) {
  3732.                 $v_result = 2;
  3733.       }
  3734.       else if ($i < $v_list_dir_size) {
  3735.                 $v_result = 0;
  3736.       }
  3737.     }
  3738.  
  3739.         return $v_result;
  3740.   }
  3741.   
  3742.                         function PclZipUtilCopyBlock($p_src, $p_dest, $p_size, $p_mode=0)
  3743.   {
  3744.     $v_result = 1;
  3745.  
  3746.     if ($p_mode==0)
  3747.     {
  3748.       while ($p_size != 0)
  3749.       {
  3750.         $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
  3751.         $v_buffer = @fread($p_src, $v_read_size);
  3752.         @fwrite($p_dest, $v_buffer, $v_read_size);
  3753.         $p_size -= $v_read_size;
  3754.       }
  3755.     }
  3756.     else if ($p_mode==1)
  3757.     {
  3758.       while ($p_size != 0)
  3759.       {
  3760.         $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
  3761.         $v_buffer = @gzread($p_src, $v_read_size);
  3762.         @fwrite($p_dest, $v_buffer, $v_read_size);
  3763.         $p_size -= $v_read_size;
  3764.       }
  3765.     }
  3766.     else if ($p_mode==2)
  3767.     {
  3768.       while ($p_size != 0)
  3769.       {
  3770.         $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
  3771.         $v_buffer = @fread($p_src, $v_read_size);
  3772.         @gzwrite($p_dest, $v_buffer, $v_read_size);
  3773.         $p_size -= $v_read_size;
  3774.       }
  3775.     }
  3776.     else if ($p_mode==3)
  3777.     {
  3778.       while ($p_size != 0)
  3779.       {
  3780.         $v_read_size = ($p_size < PCLZIP_READ_BLOCK_SIZE ? $p_size : PCLZIP_READ_BLOCK_SIZE);
  3781.         $v_buffer = @gzread($p_src, $v_read_size);
  3782.         @gzwrite($p_dest, $v_buffer, $v_read_size);
  3783.         $p_size -= $v_read_size;
  3784.       }
  3785.     }
  3786.  
  3787.         return $v_result;
  3788.   }
  3789.   
  3790.                           function PclZipUtilRename($p_src, $p_dest)
  3791.   {
  3792.     $v_result = 1;
  3793.  
  3794.         if (!@rename($p_src, $p_dest)) {
  3795.  
  3796.             if (!@copy($p_src, $p_dest)) {
  3797.         $v_result = 0;
  3798.       }
  3799.       else if (!@unlink($p_src)) {
  3800.         $v_result = 0;
  3801.       }
  3802.     }
  3803.  
  3804.         return $v_result;
  3805.   }
  3806.   
  3807.                     function PclZipUtilOptionText($p_option)
  3808.   {
  3809.     
  3810.     $v_list = get_defined_constants();
  3811.     for (reset($v_list); $v_key = key($v_list); next($v_list)) {
  3812. 	    $v_prefix = substr($v_key, 0, 10);
  3813. 	    if ((   ($v_prefix == 'PCLZIP_OPT')
  3814.            || ($v_prefix == 'PCLZIP_CB_')
  3815.            || ($v_prefix == 'PCLZIP_ATT'))
  3816. 	        && ($v_list[$v_key] == $p_option)) {
  3817.         return $v_key;
  3818. 	    }
  3819.     }
  3820.     
  3821.     $v_result = 'Unknown';
  3822.  
  3823.     return $v_result;
  3824.   }
  3825.   
  3826.                         function PclZipUtilTranslateWinPath($p_path, $p_remove_disk_letter=true)
  3827.   {
  3828.     if (stristr(php_uname(), 'windows')) {
  3829.             if (($p_remove_disk_letter) && (($v_position = strpos($p_path, ':')) != false)) {
  3830.           $p_path = substr($p_path, $v_position+1);
  3831.       }
  3832.             if ((strpos($p_path, '\\') > 0) || (substr($p_path, 0,1) == '\\')) {
  3833.           $p_path = strtr($p_path, '\\', '/');
  3834.       }
  3835.     }
  3836.     return $p_path;
  3837.   }
  3838.   
  3839.   
  3840.   function Comments_Shcms()
  3841.   {
  3842.   global $filepath;
  3843. $zip = new ZipArchive;  
  3844.  
  3845. if ($zip->open($filepath) === TRUE)  
  3846.  
  3847. {  
  3848.  
  3849. $zip->setArchiveComment(utf8_win('SHCMS Engine - CMS система управления сайтом '));  
  3850.  
  3851. $zip->addFromString('ReadMe_SHCMS.txt','SHCMS Engine - CMS система управления сайтом
  3852.  
  3853. Официальныый сайт: shcms.ru
  3854. ');  
  3855.  
  3856. $zip->close();  
  3857.  
  3858.  
  3859. }  
  3860. }
  3861. ?>