<?php

/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**

* File::CSV

*

* PHP versions 4 and 5

*

* Copyright (c) 1997-2008,

* Vincent Blavet <vincent@phpconcept.net>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* * Redistributions of source code must retain the above copyright notice,

* this list of conditions and the following disclaimer.

* * Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*

*

* @category File_Formats

* @package Archive_Tar

* @author Vincent Blavet <vincent@phpconcept.net>

* @copyright 1997-2008 The Authors

* @license http://www.opensource.org/licenses/bsd-license.php New BSD License

* @version CVS: $Id: Tar.php,v 1.43 2008/10/30 17:58:42 dufuz Exp $

* @link http://pear.php.net/package/Archive_Tar

*/

require_once(CLASS_DIR."pear.php");

define ('ARCHIVE_TAR_ATT_SEPARATOR', 90001);

define ('ARCHIVE_TAR_END_BLOCK', pack("a512", ''));

/**

* Creates a (compressed) Tar archive

*

* @author Vincent Blavet <vincent@phpconcept.net>

* @version $Revision: 1.43 $

* @license http://www.opensource.org/licenses/bsd-license.php New BSD License

* @package Archive_Tar

*/

class Archive_Tar extends PEAR

{

/**

* @var string Name of the Tar

*/

var $_tarname='';

/**

* @var boolean if true, the Tar file will be gzipped

*/

var $_compress=false;

/**

* @var string Type of compression : 'none', 'gz' or 'bz2'

*/

var $_compress_type='none';

/**

* @var string Explode separator

*/

var $_separator=' ';

/**

* @var file descriptor

*/

var $_file=0;

/**

* @var string Local Tar name of a remote Tar (http:// or ftp://)

*/

var $_temp_tarname='';

// {{{ constructor

/**

* Archive_Tar Class constructor. This flavour of the constructor only

* declare a new Archive_Tar object, identifying it by the name of the

* tar file.

* If the compress argument is set the tar will be read or created as a

* gzip or bz2 compressed TAR file.

*

* @param string $p_tarname The name of the tar archive to create

* @param string $p_compress can be null, 'gz' or 'bz2'. This

* parameter indicates if gzip or bz2 compression

* is required. For compatibility reason the

* boolean value 'true' means 'gz'.

* @access public

*/

function Archive_Tar($p_tarname, $p_compress = null)

{

$this->PEAR();

$this->_compress = false;

$this->_compress_type = 'none';

if (($p_compress === null) || ($p_compress == '')) {

if (@file_exists($p_tarname)) {

if ($fp = @fopen($p_tarname, "rb")) {

// look for gzip magic cookie

$data = fread($fp, 2);

fclose($fp);

if ($data == "\37\213") {

$this->_compress = true;

$this->_compress_type = 'gz';

// No sure it's enought for a magic code ....

} elseif ($data == "BZ") {

$this->_compress = true;

$this->_compress_type = 'bz2';

}

}

} else {

// probably a remote file or some file accessible

// through a stream interface

if (substr($p_tarname, -2) == 'gz') {

$this->_compress = true;

$this->_compress_type = 'gz';

} elseif ((substr($p_tarname, -3) == 'bz2') ||

(substr($p_tarname, -2) == 'bz')) {

$this->_compress = true;

$this->_compress_type = 'bz2';

}

}

} else {

if (($p_compress === true) || ($p_compress == 'gz')) {

$this->_compress = true;

$this->_compress_type = 'gz';

} else if ($p_compress == 'bz2') {

$this->_compress = true;

$this->_compress_type = 'bz2';

} else {

$this->_error("Unsupported compression type '$p_compress'\n".

"Supported types are 'gz' and 'bz2'.\n");

return false;

}

}

$this->_tarname = $p_tarname;

if ($this->_compress) { // assert zlib or bz2 extension support

if ($this->_compress_type == 'gz')

$extname = 'zlib';

else if ($this->_compress_type == 'bz2')

$extname = 'bz2';

if (!extension_loaded($extname)) {

PEAR::loadExtension($extname);

}

if (!extension_loaded($extname)) {

$this->_error("The extension '$extname' couldn't be found.\n".

"Please make sure your version of PHP was built ".

"with '$extname' support.\n");

return false;

}

}

}

// }}}

// {{{ destructor

function _Archive_Tar()

{

$this->_close();

// ----- Look for a local copy to delete

if ($this->_temp_tarname != '')

@unlink($this->_temp_tarname);

$this->_PEAR();

}

// }}}

// {{{ create()

/**

* This method creates the archive file and add the files / directories

* that are listed in $p_filelist.

* If a file with the same name exist and is writable, it is replaced

* by the new tar.

* The method return false and a PEAR error text.

* The $p_filelist parameter can be an array of string, each string

* representing a filename or a directory name with their path if

* needed. It can also be a single string with names separated by a

* single blank.

* For each directory added in the archive, the files and

* sub-directories are also added.

* See also createModify() method for more details.

*

* @param array $p_filelist An array of filenames and directory names, or a

* single string with names separated by a single

* blank space.

* @return true on success, false on error.

* @see createModify()

* @access public

*/

function create($p_filelist)

{

return $this->createModify($p_filelist, '', '');

}

// }}}

// {{{ add()

/**

* This method add the files / directories that are listed in $p_filelist in

* the archive. If the archive does not exist it is created.

* The method return false and a PEAR error text.

* The files and directories listed are only added at the end of the archive,

* even if a file with the same name is already archived.

* See also createModify() method for more details.

*

* @param array $p_filelist An array of filenames and directory names, or a

* single string with names separated by a single

* blank space.

* @return true on success, false on error.

* @see createModify()

* @access public

*/

function add($p_filelist)

{

return $this->addModify($p_filelist, '', '');

}

// }}}

// {{{ extract()

function extract($p_path='')

{

return $this->extractModify($p_path, '');

}

// }}}

// {{{ listContent()

function listContent()

{

$v_list_detail = array();

if ($this->_openRead()) {

if (!$this->_extractList('', $v_list_detail, "list", '', '')) {

unset($v_list_detail);

$v_list_detail = 0;

}

$this->_close();

}

return $v_list_detail;

}

// }}}

// {{{ createModify()

/**

* This method creates the archive file and add the files / directories

* that are listed in $p_filelist.

* If the file already exists and is writable, it is replaced by the

* new tar. It is a create and not an add. If the file exists and is

* read-only or is a directory it is not replaced. The method return

* false and a PEAR error text.

* The $p_filelist parameter can be an array of string, each string

* representing a filename or a directory name with their path if

* needed. It can also be a single string with names separated by a

* single blank.

* The path indicated in $p_remove_dir will be removed from the

* memorized path of each file / directory listed when this path

* exists. By default nothing is removed (empty path '')

* The path indicated in $p_add_dir will be added at the beginning of

* the memorized path of each file / directory listed. However it can

* be set to empty ''. The adding of a path is done after the removing

* of path.

* The path add/remove ability enables the user to prepare an archive

* for extraction in a different path than the origin files are.

* See also addModify() method for file adding properties.

*

* @param array $p_filelist An array of filenames and directory names,

* or a single string with names separated by

* a single blank space.

* @param string $p_add_dir A string which contains a path to be added

* to the memorized path of each element in

* the list.

* @param string $p_remove_dir A string which contains a path to be

* removed from the memorized path of each

* element in the list, when relevant.

* @return boolean true on success, false on error.

* @access public

* @see addModify()

*/

function createModify($p_filelist, $p_add_dir, $p_remove_dir='')

{

$v_result = true;

if (!$this->_openWrite())

return false;

if ($p_filelist != '') {

if (is_array($p_filelist))

$v_list = $p_filelist;

elseif (is_string($p_filelist))

$v_list = explode($this->_separator, $p_filelist);

else {

$this->_cleanFile();

$this->_error('Invalid file list');

return false;

}

$v_result = $this->_addList($v_list, $p_add_dir, $p_remove_dir);

}

if ($v_result) {

$this->_writeFooter();

$this->_close();

} else

$this->_cleanFile();

return $v_result;

}

// }}}

// {{{ addModify()

/**

* This method add the files / directories listed in $p_filelist at the

* end of the existing archive. If the archive does not yet exists it

* is created.

* The $p_filelist parameter can be an array of string, each string

* representing a filename or a directory name with their path if

* needed. It can also be a single string with names separated by a

* single blank.

* The path indicated in $p_remove_dir will be removed from the

* memorized path of each file / directory listed when this path

* exists. By default nothing is removed (empty path '')

* The path indicated in $p_add_dir will be added at the beginning of

* the memorized path of each file / directory listed. However it can

* be set to empty ''. The adding of a path is done after the removing

* of path.

* The path add/remove ability enables the user to prepare an archive

* for extraction in a different path than the origin files are.

* If a file/dir is already in the archive it will only be added at the

* end of the archive. There is no update of the existing archived

* file/dir. However while extracting the archive, the last file will

* replace the first one. This results in a none optimization of the

* archive size.

* If a file/dir does not exist the file/dir is ignored. However an

* error text is send to PEAR error.

* If a file/dir is not readable the file/dir is ignored. However an

* error text is send to PEAR error.

*

* @param array $p_filelist An array of filenames and directory

* names, or a single string with names

* separated by a single blank space.

* @param string $p_add_dir A string which contains a path to be

* added to the memorized path of each

* element in the list.

* @param string $p_remove_dir A string which contains a path to be

* removed from the memorized path of

* each element in the list, when

* relevant.

* @return true on success, false on error.

* @access public

*/

function addModify($p_filelist, $p_add_dir, $p_remove_dir='')

{

$v_result = true;

if (!$this->_isArchive())

$v_result = $this->createModify($p_filelist, $p_add_dir,

$p_remove_dir);

else {

if (is_array($p_filelist))

$v_list = $p_filelist;

elseif (is_string($p_filelist))

$v_list = explode($this->_separator, $p_filelist);

else {

$this->_error('Invalid file list');

return false;

}

$v_result = $this->_append($v_list, $p_add_dir, $p_remove_dir);

}

return $v_result;

}

// }}}

// {{{ addString()

/**

* This method add a single string as a file at the

* end of the existing archive. If the archive does not yet exists it

* is created.

*

* @param string $p_filename A string which contains the full

* filename path that will be associated

* with the string.

* @param string $p_string The content of the file added in

* the archive.

* @return true on success, false on error.

* @access public

*/

function addString($p_filename, $p_string)

{

$v_result = true;

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

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

return false;

}

$this->_close();

}

if (!$this->_openAppend())

return false;

// Need to check the get back to the temporary file ? ....

$v_result = $this->_addString($p_filename, $p_string);

$this->_writeFooter();

$this->_close();

return $v_result;

}

// }}}

// {{{ extractModify()

/**

* This method extract all the content of the archive in the directory

* indicated by $p_path. When relevant the memorized path of the

* files/dir can be modified by removing the $p_remove_path path at the

* beginning of the file/dir path.

* While extracting a file, if the directory path does not exists it is

* created.

* While extracting a file, if the file already exists it is replaced

* without looking for last modification date.

* While extracting a file, if the file already exists and is write

* protected, the extraction is aborted.

* While extracting a file, if a directory with the same name already

* exists, the extraction is aborted.

* While extracting a directory, if a file with the same name already

* exists, the extraction is aborted.

* While extracting a file/directory if the destination directory exist

* and is write protected, or does not exist but can not be created,

* the extraction is aborted.

* If after extraction an extracted file does not show the correct

* stored file size, the extraction is aborted.

* When the extraction is aborted, a PEAR error text is set and false

* is returned. However the result can be a partial extraction that may

* need to be manually cleaned.

*

* @param string $p_path The path of the directory where the

* files/dir need to by extracted.

* @param string $p_remove_path Part of the memorized path that can be

* removed if present at the beginning of

* the file/dir path.

* @return boolean true on success, false on error.

* @access public

* @see extractList()

*/

function extractModify($p_path, $p_remove_path)

{

$v_result = true;

$v_list_detail = array();

if ($v_result = $this->_openRead()) {

$v_result = $this->_extractList($p_path, $v_list_detail,

"complete", 0, $p_remove_path);

$this->_close();

}

return $v_result;

}

// }}}

// {{{ extractInString()

/**

* This method extract from the archive one file identified by $p_filename.

* The return value is a string with the file content, or NULL on error.

* @param string $p_filename The path of the file to extract in a string.

* @return a string with the file content or NULL.

* @access public

*/

function extractInString($p_filename)

{

if ($this->_openRead()) {

$v_result = $this->_extractInString($p_filename);

$this->_close();

} else {

$v_result = NULL;

}

return $v_result;

}

// }}}

// {{{ extractList()

/**

* This method extract from the archive only the files indicated in the

* $p_filelist. These files are extracted in the current directory or

* in the directory indicated by the optional $p_path parameter.

* If indicated the $p_remove_path can be used in the same way as it is

* used in extractModify() method.

* @param array $p_filelist An array of filenames and directory names,

* or a single string with names separated

* by a single blank space.

* @param string $p_path The path of the directory where the

* files/dir need to by extracted.

* @param string $p_remove_path Part of the memorized path that can be

* removed if present at the beginning of

* the file/dir path.

* @return true on success, false on error.

* @access public

* @see extractModify()

*/

function extractList($p_filelist, $p_path='', $p_remove_path='')

{

$v_result = true;

$v_list_detail = array();

if (is_array($p_filelist))

$v_list = $p_filelist;

elseif (is_string($p_filelist))

$v_list = explode($this->_separator, $p_filelist);

else {

$this->_error('Invalid string list');

return false;

}

if ($v_result = $this->_openRead()) {

$v_result = $this->_extractList($p_path, $v_list_detail, "partial",

$v_list, $p_remove_path);

$this->_close();

}

return $v_result;

}

// }}}

// {{{ setAttribute()

/**

* This method set specific attributes of the archive. It uses a variable

* list of parameters, in the format attribute code + attribute values :

* $arch->setAttribute(ARCHIVE_TAR_ATT_SEPARATOR, ',');

* @param mixed $argv variable list of attributes and values

* @return true on success, false on error.

* @access public

*/

function setAttribute()

{

$v_result = true;

// ----- Get the number of variable list of arguments

if (($v_size = func_num_args()) == 0) {

return true;

}

// ----- Get the arguments

$v_att_list = func_get_args();

// ----- Read the attributes

$i=0;

while ($i<$v_size) {

// ----- Look for next option

switch ($v_att_list[$i]) {

// ----- Look for options that request a string value

case ARCHIVE_TAR_ATT_SEPARATOR :

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

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

$this->_error('Invalid number of parameters for '

.'attribute ARCHIVE_TAR_ATT_SEPARATOR');

return false;

}

// ----- Get the value

$this->_separator = $v_att_list[$i+1];

$i++;

break;

default :

$this->_error('Unknow attribute code '.$v_att_list[$i].'');

return false;

}

// ----- Next attribute

$i++;

}

return $v_result;

}

// }}}

// {{{ _error()

function raiseError($p_message)

{

// ----- To be completed

//echo $p_message;

$this->error = $p_message;

}

// }}}

// {{{ _error()

function _error($p_message)

{

// ----- To be completed

$this->raiseError($p_message);

}

// }}}

// {{{ _warning()

function _warning($p_message)

{

// ----- To be completed

$this->raiseError($p_message);

}

// }}}

// {{{ _isArchive()

function _isArchive($p_filename=NULL)

{

if ($p_filename == NULL) {

$p_filename = $this->_tarname;

}

clearstatcache();

return @is_file($p_filename) && !@is_link($p_filename);

}

// }}}

// {{{ _openWrite()

function _openWrite()

{

if ($this->_compress_type == 'gz')

$this->_file = @gzopen($this->_tarname, "wb9");

else if ($this->_compress_type == 'bz2')

$this->_file = @bzopen($this->_tarname, "w");

else if ($this->_compress_type == 'none')

$this->_file = @fopen($this->_tarname, "wb");

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

if ($this->_file == 0) {

$this->_error('Unable to open in write mode \''

.$this->_tarname.'\'');

return false;

}

return true;

}

// }}}

// {{{ _openRead()

function _openRead()

{

if (strtolower(substr($this->_tarname, 0, 7)) == 'http://') {

// ----- Look if a local copy need to be done

if ($this->_temp_tarname == '') {

$this->_temp_tarname = uniqid('tar').'.tmp';

if (!$v_file_from = @fopen($this->_tarname, 'rb')) {

$this->_error('Unable to open in read mode \''

.$this->_tarname.'\'');

$this->_temp_tarname = '';

return false;

}

if (!$v_file_to = @fopen($this->_temp_tarname, 'wb')) {

$this->_error('Unable to open in write mode \''

.$this->_temp_tarname.'\'');

$this->_temp_tarname = '';

return false;

}

while ($v_data = @fread($v_file_from, 1024))

@fwrite($v_file_to, $v_data);

@fclose($v_file_from);

@fclose($v_file_to);

}

// ----- File to open if the local copy

$v_filename = $this->_temp_tarname;

} else

// ----- File to open if the normal Tar file

$v_filename = $this->_tarname;

if ($this->_compress_type == 'gz')

$this->_file = @gzopen($v_filename, "rb");

else if ($this->_compress_type == 'bz2')

$this->_file = @bzopen($v_filename, "r");

else if ($this->_compress_type == 'none')

$this->_file = @fopen($v_filename, "rb");

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

if ($this->_file == 0) {

$this->_error('Unable to open in read mode \''.$v_filename.'\'');

return false;

}

return true;

}

// }}}

// {{{ _openReadWrite()

function _openReadWrite()

{

if ($this->_compress_type == 'gz')

$this->_file = @gzopen($this->_tarname, "r+b");

else if ($this->_compress_type == 'bz2') {

$this->_error('Unable to open bz2 in read/write mode \''

.$this->_tarname.'\' (limitation of bz2 extension)');

return false;

} else if ($this->_compress_type == 'none')

$this->_file = @fopen($this->_tarname, "r+b");

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

if ($this->_file == 0) {

$this->_error('Unable to open in read/write mode \''

.$this->_tarname.'\'');

return false;

}

return true;

}

// }}}

// {{{ _close()

function _close()

{

//if (isset($this->_file)) {

if (is_resource($this->_file)) {

if ($this->_compress_type == 'gz')

@gzclose($this->_file);

else if ($this->_compress_type == 'bz2')

@bzclose($this->_file);

else if ($this->_compress_type == 'none')

@fclose($this->_file);

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

$this->_file = 0;

}

// ----- Look if a local copy need to be erase

// Note that it might be interesting to keep the url for a time : ToDo

if ($this->_temp_tarname != '') {

@unlink($this->_temp_tarname);

$this->_temp_tarname = '';

}

return true;

}

// }}}

// {{{ _cleanFile()

function _cleanFile()

{

$this->_close();

// ----- Look for a local copy

if ($this->_temp_tarname != '') {

// ----- Remove the local copy but not the remote tarname

@unlink($this->_temp_tarname);

$this->_temp_tarname = '';

} else {

// ----- Remove the local tarname file

@unlink($this->_tarname);

}

$this->_tarname = '';

return true;

}

// }}}

// {{{ _writeBlock()

function _writeBlock($p_binary_data, $p_len=null)

{

if (is_resource($this->_file)) {

if ($p_len === null) {

if ($this->_compress_type == 'gz')

@gzputs($this->_file, $p_binary_data);

else if ($this->_compress_type == 'bz2')

@bzwrite($this->_file, $p_binary_data);

else if ($this->_compress_type == 'none')

@fputs($this->_file, $p_binary_data);

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

} else {

if ($this->_compress_type == 'gz')

@gzputs($this->_file, $p_binary_data, $p_len);

else if ($this->_compress_type == 'bz2')

@bzwrite($this->_file, $p_binary_data, $p_len);

else if ($this->_compress_type == 'none')

@fputs($this->_file, $p_binary_data, $p_len);

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

}

}

return true;

}

// }}}

// {{{ _readBlock()

function _readBlock()

{

$v_block = null;

if (is_resource($this->_file)) {

if ($this->_compress_type == 'gz')

$v_block = @gzread($this->_file, 512);

else if ($this->_compress_type == 'bz2')

$v_block = @bzread($this->_file, 512);

else if ($this->_compress_type == 'none')

$v_block = @fread($this->_file, 512);

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

}

return $v_block;

}

// }}}

// {{{ _jumpBlock()

function _jumpBlock($p_len=null)

{

if (is_resource($this->_file)) {

if ($p_len === null)

$p_len = 1;

if ($this->_compress_type == 'gz') {

@gzseek($this->_file, gztell($this->_file)+($p_len*512));

}

else if ($this->_compress_type == 'bz2') {

// ----- Replace missing bztell() and bzseek()

for ($i=0; $i<$p_len; $i++)

$this->_readBlock();

} else if ($this->_compress_type == 'none')

@fseek($this->_file, ftell($this->_file)+($p_len*512));

else

$this->_error('Unknown or missing compression type ('

.$this->_compress_type.')');

}

return true;

}

// }}}

// {{{ _writeFooter()

function _writeFooter()

{

if (is_resource($this->_file)) {

// ----- Write the last 0 filled block for end of archive

$v_binary_data = pack('a1024', '');

$this->_writeBlock($v_binary_data);

}

return true;

}

// }}}

// {{{ _addList()

function _addList($p_list, $p_add_dir, $p_remove_dir)

{

$v_result=true;

$v_header = array();

// ----- Remove potential windows directory separator

$p_add_dir = $this->_translateWinPath($p_add_dir);

$p_remove_dir = $this->_translateWinPath($p_remove_dir, false);

if (!$this->_file) {

$this->_error('Invalid file descriptor');

return false;

}

if (sizeof($p_list) == 0)

return true;

foreach ($p_list as $v_filename) {

if (!$v_result) {

break;

}

// ----- Skip the current tar name

if ($v_filename == $this->_tarname)

continue;

if ($v_filename == '')

continue;

if (!file_exists($v_filename)) {

$this->_warning("File '$v_filename' does not exist");

continue;

}

// ----- Add the file or directory header

if (!$this->_addFile($v_filename, $v_header, $p_add_dir, $p_remove_dir))

return false;

if (@is_dir($v_filename) && !@is_link($v_filename)) {

if (!($p_hdir = opendir($v_filename))) {

$this->_warning("Directory '$v_filename' can not be read");

continue;

}

while (false !== ($p_hitem = readdir($p_hdir))) {

if (($p_hitem != '.') && ($p_hitem != '..')) {

if ($v_filename != ".")

$p_temp_list[0] = $v_filename.'/'.$p_hitem;

else

$p_temp_list[0] = $p_hitem;

$v_result = $this->_addList($p_temp_list,

$p_add_dir,

$p_remove_dir);

}

}

unset($p_temp_list);

unset($p_hdir);

unset($p_hitem);

}

}

return $v_result;

}

// }}}

// {{{ _addFile()

function _addFile($p_filename, &$p_header, $p_add_dir, $p_remove_dir)

{

if (!$this->_file) {

$this->_error('Invalid file descriptor');

return false;

}

if ($p_filename == '') {

$this->_error('Invalid file name');

return false;

}

// ----- Calculate the stored filename

$p_filename = $this->_translateWinPath($p_filename, false);;

$v_stored_filename = $p_filename;

if (strcmp($p_filename, $p_remove_dir) == 0) {

return true;

}

if ($p_remove_dir != '') {

if (substr($p_remove_dir, -1) != '/')

$p_remove_dir .= '/';

if (substr($p_filename, 0, strlen($p_remove_dir)) == $p_remove_dir)

$v_stored_filename = substr($p_filename, strlen($p_remove_dir));

}

$v_stored_filename = $this->_translateWinPath($v_stored_filename);

if ($p_add_dir != '') {

if (substr($p_add_dir, -1) == '/')

$v_stored_filename = $p_add_dir.$v_stored_filename;

else

$v_stored_filename = $p_add_dir.'/'.$v_stored_filename;

}

$v_stored_filename = $this->_pathReduction($v_stored_filename);

if ($this->_isArchive($p_filename)) {

if (($v_file = @fopen($p_filename, "rb")) == 0) {

$this->_warning("Unable to open file '".$p_filename

."' in binary read mode");

return true;

}

if (!$this->_writeHeader($p_filename, $v_stored_filename))

return false;

while (($v_buffer = fread($v_file, 512)) != '') {

$v_binary_data = pack("a512", "$v_buffer");

$this->_writeBlock($v_binary_data);

}

fclose($v_file);

} else {

// ----- Only header for dir

if (!$this->_writeHeader($p_filename, $v_stored_filename))

return false;

}

return true;

}

// }}}

// {{{ _addString()

function _addString($p_filename, $p_string)

{

if (!$this->_file) {

$this->_error('Invalid file descriptor');

return false;

}