WB 2.08.x

! = Update/Change

------------------------------------- 2.8.1 -------------------------------------

29-Nov-2009 Dietmar Woellbrink (Luisehahne)

!	update module info.php (thanks to Waldschwein)

29-Nov-2009 Dietmar Woellbrink (Luisehahne)

// --------------------------------------------------------------------------------

// --------------------------------------------------------------------------------

// Vincent Blavet - vincent@phpconcept.net

// http://www.phpconcept.net

// --------------------------------------------------------------------------------

// --------------------------------------------------------------------------------

2 - What's new

==============

  Version 2.6 :

    - Code optimisation

    - New attributes PCLZIP_ATT_FILE_COMMENT gives the ability to

  In Version 2.x :

    - PclZip does only support file uncompressed or compressed with deflate (compression method 8)

    - PclZip does not support password protected zip archive

  In Version 1.2 :

<?php

// --------------------------------------------------------------------------------

// --------------------------------------------------------------------------------

// http://www.phpconcept.net

// --------------------------------------------------------------------------------

//

//   The use of this software is at the risk of the user.

//

// --------------------------------------------------------------------------------

// --------------------------------------------------------------------------------

  // ----- Constants

    define( 'PCLZIP_TEMPORARY_DIR', '' );

  }

// --------------------------------------------------------------------------------

// ***** UNDER THIS LINE NOTHING NEEDS TO BE MODIFIED *****

// --------------------------------------------------------------------------------

  // ----- Global variables

  // ----- Error codes

  //   -1 : Unable to open file in binary write mode

  // which is not correctly supported by PHP ...

  //define( 'PCLZIP_OPT_CRYPT', 77018 );

  define( 'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION', 77019 );

  // ----- File description attributes

  define( 'PCLZIP_ATT_FILE_NAME', 79001 );

  // --------------------------------------------------------------------------------

  function PclZip($p_zipname)

  {

    // ----- Tests the zlib

    if (!function_exists('gzopen'))

    {

      die('Abort '.basename(__FILE__).' : Missing zlib extensions');

    }

    $this->magic_quotes_status = -1;

    // ----- Return

    return;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function create($p_filelist)

  {

    $v_result=1;

    // ----- Reset the error handler

    // ----- Look for variable options arguments

    $v_size = func_num_args();

    // ----- Look for arguments

    if ($v_size > 1) {

      // ----- Look for first arg

      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

        // ----- Parse the options

        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

                                                   PCLZIP_CB_PRE_ADD => 'optional',

                                                   PCLZIP_CB_POST_ADD => 'optional',

                                                   PCLZIP_OPT_NO_COMPRESSION => 'optional',

                                                   //, PCLZIP_OPT_CRYPT => 'optional'

                                             ));

        if ($v_result != 1) {

          return 0;

        }

      }

      // Here we need to support the first historic synopsis of the

      // method.

      else {

        // ----- Get the first argument

        $v_options[PCLZIP_OPT_ADD_PATH] = $v_arg_list[0];

        else if ($v_size > 2) {

          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER,

		                       "Invalid number / type of arguments");

          return 0;

        }

      }

    }

    // ----- Init

    $v_string_list = array();

    // ----- Invalid variable type for $p_filelist

    else {

      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type p_filelist");

      return 0;

    }

          $v_att_list[][PCLZIP_ATT_FILE_NAME] = $v_string;

        }

        else {

        }

      }

    }

                                               $v_options,

                                               $v_supported_attributes);

      if ($v_result != 1) {

        return 0;

      }

    }

    // ----- Expand the filelist (expand directories)

    $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);

    if ($v_result != 1) {

      return 0;

    }

    // ----- Call the create fct

    $v_result = $this->privCreate($v_filedescr_list, $p_result_list, $v_options);

    if ($v_result != 1) {

      return 0;

    }

    // ----- Return

    return $p_result_list;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function add($p_filelist)

  {

    $v_result=1;

    // ----- Reset the error handler

    // ----- Look for variable options arguments

    $v_size = func_num_args();

    // ----- Look for arguments

    if ($v_size > 1) {

      // ----- Look for first arg

      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

        // ----- Parse the options

        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

                                                   PCLZIP_OPT_NO_COMPRESSION => 'optional',

                                                   PCLZIP_OPT_COMMENT => 'optional',

                                                   PCLZIP_OPT_ADD_COMMENT => 'optional',

                                                   //, PCLZIP_OPT_CRYPT => 'optional'

												   ));

        if ($v_result != 1) {

          return 0;

        }

      }

      // Here we need to support the first historic synopsis of the

      // method.

      else {

        // ----- Get the first argument

        $v_options[PCLZIP_OPT_ADD_PATH] = $v_add_path = $v_arg_list[0];

          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");

          // ----- Return

          return 0;

        }

      }

    }

    // ----- Init

    $v_string_list = array();

    $v_att_list = array();

    // ----- Invalid variable type for $p_filelist

    else {

      PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid variable type '".gettype($p_filelist)."' for p_filelist");

      return 0;

    }

                                               $v_options,

                                               $v_supported_attributes);

      if ($v_result != 1) {

        return 0;

      }

    }

    // ----- Expand the filelist (expand directories)

    $v_result = $this->privFileDescrExpand($v_filedescr_list, $v_options);

    if ($v_result != 1) {

      return 0;

    }

    // ----- Call the create fct

    $v_result = $this->privAdd($v_filedescr_list, $p_result_list, $v_options);

    if ($v_result != 1) {

      return 0;

    }

    // ----- Return

    return $p_result_list;

  }

  // --------------------------------------------------------------------------------

  //                                  write protected

  //                newer_exist : the file was not extracted because a newer file exists

  //                path_creation_fail : the file is not extracted because the folder

  //                write_error : the file was not extracted because there was a

  //                              error while writing the file

  //                read_error : the file was not extracted because there was a error

  // --------------------------------------------------------------------------------

  function listContent()

  {

    $v_result=1;

    // ----- Reset the error handler

    // ----- Check archive

    if (!$this->privCheckFormat()) {

      return(0);

    }

    if (($v_result = $this->privList($p_list)) != 1)

    {

      unset($p_list);

      return(0);

    }

    // ----- Return

    return $p_list;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function extract()

  {

    $v_result=1;

    // ----- Reset the error handler

    // ----- Check archive

    if (!$this->privCheckFormat()) {

      return(0);

    }

    // ----- Look for variable options arguments

    $v_size = func_num_args();

    // ----- Default values for option

    $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;

      // ----- Look for first arg

      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

        // ----- Parse the options

        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

                                                   PCLZIP_OPT_EXTRACT_IN_OUTPUT => 'optional',

                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'

                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'

												    ));

        if ($v_result != 1) {

          return 0;

        }

      // Here we need to support the first historic synopsis of the

      // method.

      else {

        // ----- Get the first argument

        $v_path = $v_arg_list[0];

          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");

          // ----- Return

          return 0;

        }

      }

    }

    // ----- Trace

    // ----- Call the extracting fct

    $p_list = array();

	                                     $v_remove_all_path, $v_options);

    if ($v_result < 1) {

      unset($p_list);

      return(0);

    }

    // ----- Return

    return $p_list;

  }

  // --------------------------------------------------------------------------------

  //function extractByIndex($p_index, options...)

  function extractByIndex($p_index)

  {

    $v_result=1;

    // ----- Reset the error handler

    // ----- Check archive

    if (!$this->privCheckFormat()) {

      return(0);

    }

    // ----- Look for variable options arguments

    $v_size = func_num_args();

    // ----- Default values for option

    $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;

      // ----- Look for first arg

      if ((is_integer($v_arg_list[0])) && ($v_arg_list[0] > 77000)) {

        // ----- Parse the options

        $v_result = $this->privParseOptions($v_arg_list, $v_size, $v_options,

                                                   PCLZIP_OPT_SET_CHMOD => 'optional',

                                                   PCLZIP_OPT_REPLACE_NEWER => 'optional'

                                                   ,PCLZIP_OPT_STOP_ON_ERROR => 'optional'

												   ));

        if ($v_result != 1) {

          return 0;

        }

        }

        if (!isset($v_options[PCLZIP_OPT_EXTRACT_AS_STRING])) {

          $v_options[PCLZIP_OPT_EXTRACT_AS_STRING] = FALSE;

        }

        else {

        }

      }

      // Here we need to support the first historic synopsis of the

      // method.

      else {

        // ----- Get the first argument

        $v_path = $v_arg_list[0];

          PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid number / type of arguments");

          // ----- Return

          return 0;

        }

      }

    }

    // ----- Trace

    // ----- Trick

    // Here I want to reuse extractByRule(), so I need to parse the $p_index

    $v_result = $this->privParseOptions($v_arg_trick, sizeof($v_arg_trick), $v_options_trick,

                                        array (PCLZIP_OPT_BY_INDEX => 'optional' ));

    if ($v_result != 1) {

        return 0;

    }

    $v_options[PCLZIP_OPT_BY_INDEX] = $v_options_trick[PCLZIP_OPT_BY_INDEX];

    // ----- Call the extracting fct

    if (($v_result = $this->privExtractByRule($p_list, $v_path, $v_remove_path, $v_remove_all_path, $v_options)) < 1) {

        return(0);

    }

    // ----- Return

    return $p_list;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function delete()

  {

    $v_result=1;

    // ----- Reset the error handler

    // ----- Check archive

    if (!$this->privCheckFormat()) {

      return(0);

    }

    // ----- Look for variable options arguments

    $v_size = func_num_args();

    // ----- Look for arguments

    if ($v_size > 0) {

                                               PCLZIP_OPT_BY_PREG => 'optional',

                                               PCLZIP_OPT_BY_INDEX => 'optional' ));

      if ($v_result != 1) {

          return 0;

      }

    }

    if (($v_result = $this->privDeleteByRule($v_list, $v_options)) != 1) {

      $this->privSwapBackMagicQuotes();

      unset($v_list);

      return(0);

    }

    $this->privSwapBackMagicQuotes();

    // ----- Return

    return $v_list;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function deleteByIndex($p_index)

  {

    $p_list = $this->delete(PCLZIP_OPT_BY_INDEX, $p_index);

    // ----- Return

    return $p_list;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function properties()

  {

    // ----- Reset the error handler

    $this->privErrorReset();

    // ----- Check archive

    if (!$this->privCheckFormat()) {

      $this->privSwapBackMagicQuotes();

      return(0);

    }

    if (@is_file($this->zipname))

    {

      // ----- Open the zip file

      if (($this->zip_fd = @fopen($this->zipname, 'rb')) == 0)

      {

        $this->privSwapBackMagicQuotes();

        PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, 'Unable to open archive \''.$this->zipname.'\' in binary read mode');

        // ----- Return

        return 0;

      }

      if (($v_result = $this->privReadEndCentralDir($v_central_dir)) != 1)

      {

        $this->privSwapBackMagicQuotes();

        return 0;

      }

    $this->privSwapBackMagicQuotes();

    // ----- Return

    return $v_prop;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function duplicate($p_archive)

  {

    $v_result = 1;

    // ----- Reset the error handler

    // ----- Look if the $p_archive is a PclZip object

    if ((is_object($p_archive)) && (get_class($p_archive) == 'pclzip'))

    {

      // ----- Duplicate the archive

      $v_result = $this->privDuplicate($p_archive->zipname);

    // ----- Look if the $p_archive is a string (so a filename)

    else if (is_string($p_archive))

    {

      // ----- Check that $p_archive is a valid zip file

      // TBC : Should also check the archive format

    }

    // ----- Return

    return $v_result;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function merge($p_archive_to_add)

  {

    $v_result = 1;

    // ----- Reset the error handler

    // ----- Check archive

    if (!$this->privCheckFormat()) {

      return(0);

    }

    // ----- Look if the $p_archive_to_add is a PclZip object

    if ((is_object($p_archive_to_add)) && (get_class($p_archive_to_add) == 'pclzip'))

    {

      // ----- Merge the archive

      $v_result = $this->privMerge($p_archive_to_add);

    // ----- Look if the $p_archive_to_add is a string (so a filename)

    else if (is_string($p_archive_to_add))

    {

      // ----- Create a temporary archive

      $v_object_archive = new PclZip($p_archive_to_add);

    }

    // ----- Return

    return $v_result;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function privCheckFormat($p_level=0)

  {

    $v_result = true;

	// ----- Reset the file system cache

    if (!is_file($this->zipname)) {

      // ----- Error log

      PclZip::privErrorLog(PCLZIP_ERR_MISSING_FILE, "Missing archive file '".$this->zipname."'");

      return(false);

    }

    if (!is_readable($this->zipname)) {

      // ----- Error log

      PclZip::privErrorLog(PCLZIP_ERR_READ_OPEN_FAIL, "Unable to read archive '".$this->zipname."'");

      return(false);

    }

    // TBC

    // ----- Return

    return $v_result;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function privParseOptions(&$p_options_list, $p_size, &$v_result_list, $v_requested_options=false)

  {

    $v_result=1;

    // ----- Read the options

    $i=0;

    while ($i<$p_size) {

      // ----- Check if the option is supported

      if (!isset($v_requested_options[$p_options_list[$i]])) {

        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid optional parameter '".$p_options_list[$i]."' for this method");

        // ----- Return

        return PclZip::errorCode();

      }

            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

          // ----- Get the value

          $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);

          $i++;

        break;

        case PCLZIP_OPT_EXTRACT_DIR_RESTRICTION :

          // ----- Check the number of parameters

          if (($i+1) >= $p_size) {

            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

          if (   is_string($p_options_list[$i+1])

              && ($p_options_list[$i+1] != '')) {

            $v_result_list[$p_options_list[$i]] = PclZipUtilTranslateWinPath($p_options_list[$i+1], FALSE);

            $i++;

          }

          else {

          }

        break;

            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

          $i++;

        break;

        // ----- Look for options that request an EREG or PREG expression

        case PCLZIP_OPT_BY_EREG :

        case PCLZIP_OPT_BY_PREG :

        //case PCLZIP_OPT_CRYPT :

          // ----- Check the number of parameters

            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Wrong parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

          $i++;

        break;

								 ."'");

            // ----- Return

            return PclZip::errorCode();

          }

								 ."'");

            // ----- Return

            return PclZip::errorCode();

          }

          $i++;

        break;

            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

          // ----- Get the value

          $v_work_list = array();

          if (is_string($p_options_list[$i+1])) {

              // ----- Remove spaces

              $p_options_list[$i+1] = strtr($p_options_list[$i+1], ' ', '');

              $v_work_list = explode(",", $p_options_list[$i+1]);

          }

          else if (is_integer($p_options_list[$i+1])) {

              $v_work_list[0] = $p_options_list[$i+1].'-'.$p_options_list[$i+1];

          }

          else if (is_array($p_options_list[$i+1])) {

              $v_work_list = $p_options_list[$i+1];

          }

          else {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Value must be integer, string or array for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

                  PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Too many values in index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");

                  // ----- Return

                  return PclZip::errorCode();

              }

              // ----- Look for list sort

              if ($v_result_list[$p_options_list[$i]][$j]['start'] < $v_sort_value) {

                  $v_sort_flag=true;

                  // ----- TBC : An automatic sort should be writen ...

                  PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Invalid order of index range for option '".PclZipUtilOptionText($p_options_list[$i])."'");

                  // ----- Return

                  return PclZip::errorCode();

              }

              $v_sort_value = $v_result_list[$p_options_list[$i]][$j]['start'];

          // ----- Sort the items

          if ($v_sort_flag) {

              // TBC : To Be Completed

          }

          // ----- Next option

        case PCLZIP_OPT_REPLACE_NEWER :

        case PCLZIP_OPT_STOP_ON_ERROR :

          $v_result_list[$p_options_list[$i]] = true;

        break;

        // ----- Look for options that request an octal value

            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

          // ----- Get the value

          $v_result_list[$p_options_list[$i]] = $p_options_list[$i+1];

          $i++;

        break;

            PclZip::privErrorLog(PCLZIP_ERR_MISSING_OPTION_VALUE, "Missing parameter value for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

          // ----- Get the value

          $v_function_name = $p_options_list[$i+1];

          // ----- Check that the value is a valid existing function

          if (!function_exists($v_function_name)) {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_OPTION_VALUE, "Function '".$v_function_name."()' is not an existing function for option '".PclZipUtilOptionText($p_options_list[$i])."'");

            // ----- Return

            return PclZip::errorCode();

          }

							   .$p_options_list[$i]."'");

          // ----- Return

          return PclZip::errorCode();

      }

      for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {

        // ----- Look for mandatory option

        if ($v_requested_options[$key] == 'mandatory') {

          // ----- Look if present

          if (!isset($v_result_list[$key])) {

            // ----- Error log

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");

            // ----- Return

            return PclZip::errorCode();

          }

        }

      }

    }

    // ----- Return

    return $v_result;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  // Function : privFileDescrParseAtt()

  // Description :

  // Parameters :

  // --------------------------------------------------------------------------------

  function privFileDescrParseAtt(&$p_file_list, &$p_filedescr, $v_options, $v_requested_options=false)

  {

    $v_result=1;

    // ----- For each file in the list check the attributes

        PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Invalid file attribute '".$v_key."' for this file");

        // ----- Return

        return PclZip::errorCode();

      }

        case PCLZIP_ATT_FILE_NAME :

          if (!is_string($v_value)) {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

          $p_filedescr['filename'] = PclZipUtilPathReduction($v_value);

          if ($p_filedescr['filename'] == '') {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty filename for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

        case PCLZIP_ATT_FILE_NEW_SHORT_NAME :

          if (!is_string($v_value)) {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

          $p_filedescr['new_short_name'] = PclZipUtilPathReduction($v_value);

          if ($p_filedescr['new_short_name'] == '') {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty short filename for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

        break;

        case PCLZIP_ATT_FILE_NEW_FULL_NAME :

          if (!is_string($v_value)) {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

          $p_filedescr['new_full_name'] = PclZipUtilPathReduction($v_value);

          if ($p_filedescr['new_full_name'] == '') {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid empty full filename for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

        break;

        case PCLZIP_ATT_FILE_COMMENT :

          if (!is_string($v_value)) {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". String expected for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

          $p_filedescr['comment'] = $v_value;

        break;

        case PCLZIP_ATT_FILE_MTIME :

          if (!is_integer($v_value)) {

            PclZip::privErrorLog(PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE, "Invalid type ".gettype($v_value).". Integer expected for attribute '".PclZipUtilOptionText($v_key)."'");

            return PclZip::errorCode();

          }

          $p_filedescr['mtime'] = $v_value;

        break;

        case PCLZIP_ATT_FILE_CONTENT :

          $p_filedescr['content'] = $v_value;

        break;

        default :

		                           "Unknown parameter '".$v_key."'");

          // ----- Return

          return PclZip::errorCode();

      }

        for ($key=reset($v_requested_options); $key=key($v_requested_options); $key=next($v_requested_options)) {

          // ----- Look for mandatory option

          if ($v_requested_options[$key] == 'mandatory') {

            // ----- Look if present

            if (!isset($p_file_list[$key])) {

              PclZip::privErrorLog(PCLZIP_ERR_INVALID_PARAMETER, "Missing mandatory parameter ".PclZipUtilOptionText($key)."(".$key.")");

              return PclZip::errorCode();

            }

          }

    }

    // ----- Return

    return $v_result;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  // Function : privFileDescrExpand()

  // Description :

  // Parameters :

  // Return Values :

  //   1 on success.

  // --------------------------------------------------------------------------------

  function privFileDescrExpand(&$p_filedescr_list, &$p_options)

  {

    $v_result=1;

    // ----- Create a result list

    // ----- Look each entry

    for ($i=0; $i<sizeof($p_filedescr_list); $i++) {

      // ----- Get filedescr

      $v_descr = $p_filedescr_list[$i];

      // ----- Reduce the filename

      $v_descr['filename'] = PclZipUtilPathReduction($v_descr['filename']);

      // ----- Look for real file or folder

      if (file_exists($v_descr['filename'])) {

        if (@is_file($v_descr['filename'])) {

          $v_descr['type'] = 'file';

        }

        else if (@is_dir($v_descr['filename'])) {

          $v_descr['type'] = 'folder';

        }

        else if (@is_link($v_descr['filename'])) {

          // skip

          continue;

        }

        else {

          // skip

          continue;

        }

      // ----- Look for string added as file

      else if (isset($v_descr['content'])) {

        $v_descr['type'] = 'virtual_file';

      }

      // ----- Missing file

      else {

        // ----- Error log

        // ----- Return

        return PclZip::errorCode();

      }

        $v_dirlist_nb = 0;

        if ($v_folder_handler = @opendir($v_descr['filename'])) {

          while (($v_item_handler = @readdir($v_folder_handler)) !== false) {

            // ----- Skip '.' and '..'

            if (($v_item_handler == '.') || ($v_item_handler == '..')) {

            // ----- Look for different stored filename

            // Because the name of the folder was changed, the name of the

            // files/sub-folders also change

              if ($v_descr['stored_filename'] != '') {

                $v_dirlist_descr[$v_dirlist_nb]['new_full_name'] = $v_descr['stored_filename'].'/'.$v_item_handler;

              }

          @closedir($v_folder_handler);

        }

        else {

          // TBC : unable to open folder in read mode

        }

        if ($v_dirlist_nb != 0) {

          // ----- Expand

          if (($v_result = $this->privFileDescrExpand($v_dirlist_descr, $p_options)) != 1) {

            return $v_result;

          }

          // ----- Concat the resulting list

          $v_result_list = array_merge($v_result_list, $v_dirlist_descr);

        }

        else {

        }

        // ----- Free local array

    $p_filedescr_list = $v_result_list;

    // ----- Return

    return $v_result;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function privCreate($p_filedescr_list, &$p_result_list, &$p_options)

  {

    $v_result=1;

    $v_list_detail = array();

    if (($v_result = $this->privOpenFd('wb')) != 1)

    {

      // ----- Return

      return $v_result;

    }

    $this->privSwapBackMagicQuotes();

    // ----- Return

    return $v_result;

  }

  // --------------------------------------------------------------------------------

  // --------------------------------------------------------------------------------

  function privAdd($p_filedescr_list, &$p_result_list, &$p_options)

  {

    $v_result=1;

    $v_list_detail = array();

    // ----- Look if the archive exists or is empty

    if ((!is_file($this->zipname)) || (filesize($this->zipname) == 0))

    {

      // ----- Do a create

      $v_result = $this->privCreate($p_filedescr_list, $p_result_list, $p_options);

      // ----- Return

      return $v_result;

    }

    // ----- Magic quotes trick

    $this->privDisableMagicQuotes();

    // ----- Open the zip file