Просмотр файла engine/classes/zip.php

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