<h2>File Contents: /home/planet5/www/4xpips.net/secure/library/pear/Archive/copy_of_copy_of_Tar.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/4xpips.net/secure/library/pear/Archive/copy_of_copy_of_Tar.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * File::CSV
 *
 * PHP versions 4 and 5
 *
 * Copyright (c) 1997-2008,
 * Vincent Blavet &lt;vincent@phpconcept.net&gt;
 * 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 &quot;AS IS&quot;
 * 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 &lt;vincent@phpconcept.net&gt;
 * @copyright   1997-2008 The Authors
 * @license     http://www.opensource.org/licenses/bsd-license.php New BSD License
 * @version     CVS: $Id: Tar.php 295988 2010-03-09 08:39:37Z mrook $
 * @link        http://pear.php.net/package/Archive_Tar
 */

require_once &#039;PEAR.php&#039;;


define (&#039;ARCHIVE_TAR_ATT_SEPARATOR&#039;, 90001);
define (&#039;ARCHIVE_TAR_END_BLOCK&#039;, pack(&quot;a512&quot;, &#039;&#039;));

/**
* Creates a (compressed) Tar archive
*
* @author   Vincent Blavet &lt;vincent@phpconcept.net&gt;
* @version  $Revision: 295988 $
* @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=&#039;&#039;;

    /**
    * @var boolean if true, the Tar file will be gzipped
    */
    var $_compress=false;

    /**
    * @var string Type of compression : &#039;none&#039;, &#039;gz&#039; or &#039;bz2&#039;
    */
    var $_compress_type=&#039;none&#039;;

    /**
    * @var string Explode separator
    */
    var $_separator=&#039; &#039;;

    /**
    * @var file descriptor
    */
    var $_file=0;

    /**
    * @var string Local Tar name of a remote Tar (http:// or ftp://)
    */
    var $_temp_tarname=&#039;&#039;;

    /**
    * @var string regular expression for ignoring files or directories
    */
    var $_ignore_regexp=&#039;&#039;;

    // {{{ 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, &#039;gz&#039; or &#039;bz2&#039;. This
    *                   parameter indicates if gzip or bz2 compression
    *                   is required.  For compatibility reason the
    *                   boolean value &#039;true&#039; means &#039;gz&#039;.
    * @access public
    */
    function Archive_Tar($p_tarname, $p_compress = null)
    {
        $this-&gt;PEAR();
        $this-&gt;_compress = false;
        $this-&gt;_compress_type = &#039;none&#039;;
        if (($p_compress === null) || ($p_compress == &#039;&#039;)) {
            if (@file_exists($p_tarname)) {
                if ($fp = @fopen($p_tarname, &quot;rb&quot;)) {
                    // look for gzip magic cookie
                    $data = fread($fp, 2);
                    fclose($fp);
                    if ($data == &quot;\37\213&quot;) {
                        $this-&gt;_compress = true;
                        $this-&gt;_compress_type = &#039;gz&#039;;
                    // No sure it&#039;s enought for a magic code ....
                    } elseif ($data == &quot;BZ&quot;) {
                        $this-&gt;_compress = true;
                        $this-&gt;_compress_type = &#039;bz2&#039;;
                    }
                }
            } else {
                // probably a remote file or some file accessible
                // through a stream interface
                if (substr($p_tarname, -2) == &#039;gz&#039;) {
                    $this-&gt;_compress = true;
                    $this-&gt;_compress_type = &#039;gz&#039;;
                } elseif ((substr($p_tarname, -3) == &#039;bz2&#039;) ||
                          (substr($p_tarname, -2) == &#039;bz&#039;)) {
                    $this-&gt;_compress = true;
                    $this-&gt;_compress_type = &#039;bz2&#039;;
                }
            }
        } else {
            if (($p_compress === true) || ($p_compress == &#039;gz&#039;)) {
                $this-&gt;_compress = true;
                $this-&gt;_compress_type = &#039;gz&#039;;
            } else if ($p_compress == &#039;bz2&#039;) {
                $this-&gt;_compress = true;
                $this-&gt;_compress_type = &#039;bz2&#039;;
            } else {
                $this-&gt;_error(&quot;Unsupported compression type &#039;$p_compress&#039;\n&quot;.
                    &quot;Supported types are &#039;gz&#039; and &#039;bz2&#039;.\n&quot;);
                return false;
            }
        }
        $this-&gt;_tarname = $p_tarname;
        if ($this-&gt;_compress) { // assert zlib or bz2 extension support
            if ($this-&gt;_compress_type == &#039;gz&#039;)
                $extname = &#039;zlib&#039;;
            else if ($this-&gt;_compress_type == &#039;bz2&#039;)
                $extname = &#039;bz2&#039;;

            if (!extension_loaded($extname)) {
                PEAR::loadExtension($extname);
            }
            if (!extension_loaded($extname)) {
                $this-&gt;_error(&quot;The extension &#039;$extname&#039; couldn&#039;t be found.\n&quot;.
                    &quot;Please make sure your version of PHP was built &quot;.
                    &quot;with &#039;$extname&#039; support.\n&quot;);
                return false;
            }
        }
    }
    // }}}

    // {{{ destructor
    function _Archive_Tar()
    {
        $this-&gt;_close();
        // ----- Look for a local copy to delete
        if ($this-&gt;_temp_tarname != &#039;&#039;)
            @unlink($this-&gt;_temp_tarname);
        $this-&gt;_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-&gt;createModify($p_filelist, &#039;&#039;, &#039;&#039;);
    }
    // }}}

    // {{{ 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-&gt;addModify($p_filelist, &#039;&#039;, &#039;&#039;);
    }
    // }}}

    // {{{ extract()
    function extract($p_path=&#039;&#039;)
    {
        return $this-&gt;extractModify($p_path, &#039;&#039;);
    }
    // }}}

    // {{{ listContent()
    function listContent()
    {
        $v_list_detail = array();

        if ($this-&gt;_openRead()) {
            if (!$this-&gt;_extractList(&#039;&#039;, $v_list_detail, &quot;list&quot;, &#039;&#039;, &#039;&#039;)) {
                unset($v_list_detail);
                $v_list_detail = 0;
            }
            $this-&gt;_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 &#039;&#039;)
    * 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 &#039;&#039;. 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=&#039;&#039;)
    {
        $v_result = true;

        if (!$this-&gt;_openWrite())
            return false;

        if ($p_filelist != &#039;&#039;) {
            if (is_array($p_filelist))
                $v_list = $p_filelist;
            elseif (is_string($p_filelist))
                $v_list = explode($this-&gt;_separator, $p_filelist);
            else {
                $this-&gt;_cleanFile();
                $this-&gt;_error(&#039;Invalid file list&#039;);
                return false;
            }

            $v_result = $this-&gt;_addList($v_list, $p_add_dir, $p_remove_dir);
        }

        if ($v_result) {
            $this-&gt;_writeFooter();
            $this-&gt;_close();
        } else
            $this-&gt;_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 &#039;&#039;)
    * 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 &#039;&#039;. 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=&#039;&#039;)
    {
        $v_result = true;

        if (!$this-&gt;_isArchive())
            $v_result = $this-&gt;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-&gt;_separator, $p_filelist);
            else {
                $this-&gt;_error(&#039;Invalid file list&#039;);
                return false;
            }

            $v_result = $this-&gt;_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-&gt;_isArchive()) {
            if (!$this-&gt;_openWrite()) {
                return false;
            }
            $this-&gt;_close();
        }

        if (!$this-&gt;_openAppend())
            return false;

        // Need to check the get back to the temporary file ? ....
        $v_result = $this-&gt;_addString($p_filename, $p_string);

        $this-&gt;_writeFooter();

        $this-&gt;_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-&gt;_openRead()) {
            $v_result = $this-&gt;_extractList($p_path, $v_list_detail,
			                                &quot;complete&quot;, 0, $p_remove_path);
            $this-&gt;_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-&gt;_openRead()) {
            $v_result = $this-&gt;_extractInString($p_filename);
            $this-&gt;_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=&#039;&#039;, $p_remove_path=&#039;&#039;)
    {
        $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-&gt;_separator, $p_filelist);
        else {
            $this-&gt;_error(&#039;Invalid string list&#039;);
            return false;
        }

        if ($v_result = $this-&gt;_openRead()) {
            $v_result = $this-&gt;_extractList($p_path, $v_list_detail, &quot;partial&quot;,
			                                $v_list, $p_remove_path);
            $this-&gt;_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-&gt;setAttribute(ARCHIVE_TAR_ATT_SEPARATOR, &#039;,&#039;);
    * @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 = &amp;func_get_args();

        // ----- Read the attributes
        $i=0;
        while ($i&lt;$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) &gt;= $v_size) {
                        $this-&gt;_error(&#039;Invalid number of parameters for &#039;
						              .&#039;attribute ARCHIVE_TAR_ATT_SEPARATOR&#039;);
                        return false;
                    }

                    // ----- Get the value
                    $this-&gt;_separator = $v_att_list[$i+1];
                    $i++;
                break;

                default :
                    $this-&gt;_error(&#039;Unknow attribute code &#039;.$v_att_list[$i].&#039;&#039;);
                    return false;
            }

            // ----- Next attribute
            $i++;
        }

        return $v_result;
    }
    // }}}

    // {{{ setIgnoreRegexp()
    /**
    * This method sets the regular expression for ignoring files and directories
    * at import, for example:
    * $arch-&gt;setIgnoreRegexp(&quot;#CVS|\.svn#&quot;);
    * @param string $regexp         regular expression defining which files or directories to ignore
    * @access public
    */
    function setIgnoreRegexp($regexp)
    {
    	$this-&gt;_ignore_regexp = $regexp;
    }
    // }}}

    // {{{ setIgnoreList()
    /**
    * This method sets the regular expression for ignoring all files and directories
    * matching the filenames in the array list at import, for example:
    * $arch-&gt;setIgnoreList(array(&#039;CVS&#039;, &#039;.svn&#039;, &#039;bin/tool&#039;));
    * @param array $list         a list of file or directory names to ignore
    * @access public
    */
    function setIgnoreList($list)
    {
    	$regexp = str_replace(array(&#039;#&#039;, &#039;.&#039;, &#039;^&#039;, &#039;$&#039;), array(&#039;\#&#039;, &#039;\.&#039;, &#039;\^&#039;, &#039;\$&#039;), $list);
    	$regexp = &#039;#/&#039;.join(&#039;$|/&#039;, $list).&#039;#&#039;;
    	$this-&gt;setIgnoreRegexp($regexp);
    }
    // }}}

    // {{{ _error()
    function _error($p_message)
    {
        // ----- To be completed
        $this-&gt;raiseError($p_message);
    }
    // }}}

    // {{{ _warning()
    function _warning($p_message)
    {
        // ----- To be completed
        $this-&gt;raiseError($p_message);
    }
    // }}}

    // {{{ _isArchive()
    function _isArchive($p_filename=NULL)
    {
        if ($p_filename == NULL) {
            $p_filename = $this-&gt;_tarname;
        }
        clearstatcache();
        return @is_file($p_filename) &amp;&amp; !@is_link($p_filename);
    }
    // }}}

    // {{{ _openWrite()
    function _openWrite()
    {
        if ($this-&gt;_compress_type == &#039;gz&#039;)
            $this-&gt;_file = @gzopen($this-&gt;_tarname, &quot;wb9&quot;);
        else if ($this-&gt;_compress_type == &#039;bz2&#039;)
            $this-&gt;_file = @bzopen($this-&gt;_tarname, &quot;w&quot;);
        else if ($this-&gt;_compress_type == &#039;none&#039;)
            $this-&gt;_file = @fopen($this-&gt;_tarname, &quot;wb&quot;);
        else
            $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
			              .$this-&gt;_compress_type.&#039;)&#039;);

        if ($this-&gt;_file == 0) {
            $this-&gt;_error(&#039;Unable to open in write mode \&#039;&#039;
			              .$this-&gt;_tarname.&#039;\&#039;&#039;);
            return false;
        }

        return true;
    }
    // }}}

    // {{{ _openRead()
    function _openRead()
    {
        if (strtolower(substr($this-&gt;_tarname, 0, 7)) == &#039;http://&#039;) {

          // ----- Look if a local copy need to be done
          if ($this-&gt;_temp_tarname == &#039;&#039;) {
              $this-&gt;_temp_tarname = uniqid(&#039;tar&#039;).&#039;.tmp&#039;;
              if (!$v_file_from = @fopen($this-&gt;_tarname, &#039;rb&#039;)) {
                $this-&gt;_error(&#039;Unable to open in read mode \&#039;&#039;
				              .$this-&gt;_tarname.&#039;\&#039;&#039;);
                $this-&gt;_temp_tarname = &#039;&#039;;
                return false;
              }
              if (!$v_file_to = @fopen($this-&gt;_temp_tarname, &#039;wb&#039;)) {
                $this-&gt;_error(&#039;Unable to open in write mode \&#039;&#039;
				              .$this-&gt;_temp_tarname.&#039;\&#039;&#039;);
                $this-&gt;_temp_tarname = &#039;&#039;;
                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-&gt;_temp_tarname;

        } else
          // ----- File to open if the normal Tar file
          $v_filename = $this-&gt;_tarname;

        if ($this-&gt;_compress_type == &#039;gz&#039;)
            $this-&gt;_file = @gzopen($v_filename, &quot;rb&quot;);
        else if ($this-&gt;_compress_type == &#039;bz2&#039;)
            $this-&gt;_file = @bzopen($v_filename, &quot;r&quot;);
        else if ($this-&gt;_compress_type == &#039;none&#039;)
            $this-&gt;_file = @fopen($v_filename, &quot;rb&quot;);
        else
            $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
			              .$this-&gt;_compress_type.&#039;)&#039;);

        if ($this-&gt;_file == 0) {
            $this-&gt;_error(&#039;Unable to open in read mode \&#039;&#039;.$v_filename.&#039;\&#039;&#039;);
            return false;
        }

        return true;
    }
    // }}}

    // {{{ _openReadWrite()
    function _openReadWrite()
    {
        if ($this-&gt;_compress_type == &#039;gz&#039;)
            $this-&gt;_file = @gzopen($this-&gt;_tarname, &quot;r+b&quot;);
        else if ($this-&gt;_compress_type == &#039;bz2&#039;) {
            $this-&gt;_error(&#039;Unable to open bz2 in read/write mode \&#039;&#039;
			              .$this-&gt;_tarname.&#039;\&#039; (limitation of bz2 extension)&#039;);
            return false;
        } else if ($this-&gt;_compress_type == &#039;none&#039;)
            $this-&gt;_file = @fopen($this-&gt;_tarname, &quot;r+b&quot;);
        else
            $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
			              .$this-&gt;_compress_type.&#039;)&#039;);

        if ($this-&gt;_file == 0) {
            $this-&gt;_error(&#039;Unable to open in read/write mode \&#039;&#039;
			              .$this-&gt;_tarname.&#039;\&#039;&#039;);
            return false;
        }

        return true;
    }
    // }}}

    // {{{ _close()
    function _close()
    {
        //if (isset($this-&gt;_file)) {
        if (is_resource($this-&gt;_file)) {
            if ($this-&gt;_compress_type == &#039;gz&#039;)
                @gzclose($this-&gt;_file);
            else if ($this-&gt;_compress_type == &#039;bz2&#039;)
                @bzclose($this-&gt;_file);
            else if ($this-&gt;_compress_type == &#039;none&#039;)
                @fclose($this-&gt;_file);
            else
                $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
				              .$this-&gt;_compress_type.&#039;)&#039;);

            $this-&gt;_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-&gt;_temp_tarname != &#039;&#039;) {
            @unlink($this-&gt;_temp_tarname);
            $this-&gt;_temp_tarname = &#039;&#039;;
        }

        return true;
    }
    // }}}

    // {{{ _cleanFile()
    function _cleanFile()
    {
        $this-&gt;_close();

        // ----- Look for a local copy
        if ($this-&gt;_temp_tarname != &#039;&#039;) {
            // ----- Remove the local copy but not the remote tarname
            @unlink($this-&gt;_temp_tarname);
            $this-&gt;_temp_tarname = &#039;&#039;;
        } else {
            // ----- Remove the local tarname file
            @unlink($this-&gt;_tarname);
        }
        $this-&gt;_tarname = &#039;&#039;;

        return true;
    }
    // }}}

    // {{{ _writeBlock()
    function _writeBlock($p_binary_data, $p_len=null)
    {
      if (is_resource($this-&gt;_file)) {
          if ($p_len === null) {
              if ($this-&gt;_compress_type == &#039;gz&#039;)
                  @gzputs($this-&gt;_file, $p_binary_data);
              else if ($this-&gt;_compress_type == &#039;bz2&#039;)
                  @bzwrite($this-&gt;_file, $p_binary_data);
              else if ($this-&gt;_compress_type == &#039;none&#039;)
                  @fputs($this-&gt;_file, $p_binary_data);
              else
                  $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
				                .$this-&gt;_compress_type.&#039;)&#039;);
          } else {
              if ($this-&gt;_compress_type == &#039;gz&#039;)
                  @gzputs($this-&gt;_file, $p_binary_data, $p_len);
              else if ($this-&gt;_compress_type == &#039;bz2&#039;)
                  @bzwrite($this-&gt;_file, $p_binary_data, $p_len);
              else if ($this-&gt;_compress_type == &#039;none&#039;)
                  @fputs($this-&gt;_file, $p_binary_data, $p_len);
              else
                  $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
				                .$this-&gt;_compress_type.&#039;)&#039;);

          }
      }
      return true;
    }
    // }}}

    // {{{ _readBlock()
    function _readBlock()
    {
      $v_block = null;
      if (is_resource($this-&gt;_file)) {
          if ($this-&gt;_compress_type == &#039;gz&#039;)
              $v_block = @gzread($this-&gt;_file, 512);
          else if ($this-&gt;_compress_type == &#039;bz2&#039;)
              $v_block = @bzread($this-&gt;_file, 512);
          else if ($this-&gt;_compress_type == &#039;none&#039;)
              $v_block = @fread($this-&gt;_file, 512);
          else
              $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
			                .$this-&gt;_compress_type.&#039;)&#039;);
      }
      return $v_block;
    }
    // }}}

    // {{{ _jumpBlock()
    function _jumpBlock($p_len=null)
    {
      if (is_resource($this-&gt;_file)) {
          if ($p_len === null)
              $p_len = 1;

          if ($this-&gt;_compress_type == &#039;gz&#039;) {
              @gzseek($this-&gt;_file, gztell($this-&gt;_file)+($p_len*512));
          }
          else if ($this-&gt;_compress_type == &#039;bz2&#039;) {
              // ----- Replace missing bztell() and bzseek()
              for ($i=0; $i&lt;$p_len; $i++)
                  $this-&gt;_readBlock();
          } else if ($this-&gt;_compress_type == &#039;none&#039;)
              @fseek($this-&gt;_file, $p_len*512, SEEK_CUR);
          else
              $this-&gt;_error(&#039;Unknown or missing compression type (&#039;
			                .$this-&gt;_compress_type.&#039;)&#039;);

      }
      return true;
    }
    // }}}

    // {{{ _writeFooter()
    function _writeFooter()
    {
      if (is_resource($this-&gt;_file)) {
          // ----- Write the last 0 filled block for end of archive
          $v_binary_data = pack(&#039;a1024&#039;, &#039;&#039;);
          $this-&gt;_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-&gt;_translateWinPath($p_add_dir);
      $p_remove_dir = $this-&gt;_translateWinPath($p_remove_dir, false);

      if (!$this-&gt;_file) {
          $this-&gt;_error(&#039;Invalid file descriptor&#039;);
          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-&gt;_tarname)
            continue;

        if ($v_filename == &#039;&#039;)
            continue;

       	// ----- ignore files and directories matching the ignore regular expression
       	if ($this-&gt;_ignore_regexp &amp;&amp; preg_match($this-&gt;_ignore_regexp, &#039;/&#039;.$v_filename)) {
            $this-&gt;_warning(&quot;File &#039;$v_filename&#039; ignored&quot;);
       	    continue;
       	}

        if (!file_exists($v_filename)) {
            $this-&gt;_warning(&quot;File &#039;$v_filename&#039; does not exist&quot;);
            continue;
        }

        // ----- Add the file or directory header
        if (!$this-&gt;_addFile($v_filename, $v_header, $p_add_dir, $p_remove_dir))
            return false;

        if (@is_dir($v_filename) &amp;&amp; !@is_link($v_filename)) {
            if (!($p_hdir = opendir($v_filename))) {
                $this-&gt;_warning(&quot;Directory &#039;$v_filename&#039; can not be read&quot;);
                continue;
            }
            while (false !== ($p_hitem = readdir($p_hdir))) {
                if (($p_hitem != &#039;.&#039;) &amp;&amp; ($p_hitem != &#039;..&#039;)) {
                    if ($v_filename != &quot;.&quot;)
                        $p_temp_list[0] = $v_filename.&#039;/&#039;.$p_hitem;
                    else
                        $p_temp_list[0] = $p_hitem;

                    $v_result = $this-&gt;_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, &amp;$p_header, $p_add_dir, $p_remove_dir)
    {
      if (!$this-&gt;_file) {
          $this-&gt;_error(&#039;Invalid file descriptor&#039;);
          return false;
      }

      if ($p_filename == &#039;&#039;) {
          $this-&gt;_error(&#039;Invalid file name&#039;);
          return false;
      }

      // ----- Calculate the stored filename
      $p_filename = $this-&gt;_translateWinPath($p_filename, false);;
      $v_stored_filename = $p_filename;
      if (strcmp($p_filename, $p_remove_dir) == 0) {
          return true;
      }
      if ($p_remove_dir != &#039;&#039;) {
          if (substr($p_remove_dir, -1) != &#039;/&#039;)
              $p_remove_dir .= &#039;/&#039;;

          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-&gt;_translateWinPath($v_stored_filename);
      if ($p_add_dir != &#039;&#039;) {
          if (substr($p_add_dir, -1) == &#039;/&#039;)
              $v_stored_filename = $p_add_dir.$v_stored_filename;
          else
              $v_stored_filename = $p_add_dir.&#039;/&#039;.$v_stored_filename;
      }

      $v_stored_filename = $this-&gt;_pathReduction($v_stored_filename);

      if ($this-&gt;_isArchive($p_filename)) {
          if (($v_file = @fopen($p_filename, &quot;rb&quot;)) == 0) {
              $this-&gt;_warning(&quot;Unable to open file &#039;&quot;.$p_filename
			                  .&quot;&#039; in binary read mode&quot;);
              return true;
          }

          if (!$this-&gt;_writeHeader($p_filename, $v_stored_filename))
              return false;

          while (($v_buffer = fread($v_file, 512)) != &#039;&#039;) {
              $v_binary_data = pack(&quot;a512&quot;, &quot;$v_buffer&quot;);
              $this-&gt;_writeBlock($v_binary_data);
          }

          fclose($v_file);

      } else {
          // ----- Only header for dir
          if (!$this-&gt;_writeHeader($p_filename, $v_stored_filename))
              return false;
      }

      return true;
    }
    // }}}

    // {{{ _addString()
    function _addString($p_filename, $p_string)
    {
      if (!$this-&gt;_file) {
          $this-&gt;_error(&#039;Invalid file descriptor&#039;);
          return false;
      }

      if ($p_filename == &#039;&#039;) {
          $this-&gt;_error(&#039;Invalid file name&#039;);
          return false;
      }

      // ----- Calculate the stored filename
      $p_filename = $this-&gt;_translateWinPath($p_filename, false);;

      if (!$this-&gt;_writeHeaderBlock($p_filename, strlen($p_string),
	                                  time(), 384, &quot;&quot;, 0, 0))
          return false;

      $i=0;
      while (($v_buffer = substr($p_string, (($i++)*512), 512)) != &#039;&#039;) {
          $v_binary_data = pack(&quot;a512&quot;, $v_buffer);
          $this-&gt;_writeBlock($v_binary_data);
      }

      return true;
    }
    // }}}

    // {{{ _writeHeader()
    function _writeHeader($p_filename, $p_stored_filename)
    {
        if ($p_stored_filename == &#039;&#039;)
            $p_stored_filename = $p_filename;
        $v_reduce_filename = $this-&gt;_pathReduction($p_stored_filename);

        if (strlen($v_reduce_filename) &gt; 99) {
          if (!$this-&gt;_writeLongHeader($v_reduce_filename))
            return false;
        }

        $v_info = lstat($p_filename);
        $v_uid = sprintf(&quot;%07s&quot;, DecOct($v_info[4]));
        $v_gid = sprintf(&quot;%07s&quot;, DecOct($v_info[5]));
        $v_perms = sprintf(&quot;%07s&quot;, DecOct($v_info[&#039;mode&#039;] &amp; 000777));

        $v_mtime = sprintf(&quot;%011s&quot;, DecOct($v_info[&#039;mtime&#039;]));

        $v_linkname = &#039;&#039;;

        if (@is_link($p_filename)) {
          $v_typeflag = &#039;2&#039;;
          $v_linkname = readlink($p_filename);
          $v_size = sprintf(&quot;%011s&quot;, DecOct(0));
        } elseif (@is_dir($p_filename)) {
          $v_typeflag = &quot;5&quot;;
          $v_size = sprintf(&quot;%011s&quot;, DecOct(0));
        } else {
          $v_typeflag = &#039;0&#039;;
          clearstatcache();
          $v_size = sprintf(&quot;%011s&quot;, DecOct($v_info[&#039;size&#039;]));
        }

        $v_magic = &#039;ustar &#039;;

        $v_version = &#039; &#039;;
        
        if (function_exists(&#039;posix_getpwuid&#039;))
        {
          $userinfo = posix_getpwuid($v_info[4]);
          $groupinfo = posix_getgrgid($v_info[5]);
          
          $v_uname = $userinfo[&#039;name&#039;];
          $v_gname = $groupinfo[&#039;name&#039;];
        }
        else
        {
          $v_uname = &#039;&#039;;
          $v_gname = &#039;&#039;;
        }

        $v_devmajor = &#039;&#039;;

        $v_devminor = &#039;&#039;;

        $v_prefix = &#039;&#039;;

        $v_binary_data_first = pack(&quot;a100a8a8a8a12a12&quot;,
		                            $v_reduce_filename, $v_perms, $v_uid,
									$v_gid, $v_size, $v_mtime);
        $v_binary_data_last = pack(&quot;a1a100a6a2a32a32a8a8a155a12&quot;,
		                           $v_typeflag, $v_linkname, $v_magic,
								   $v_version, $v_uname, $v_gname,
								   $v_devmajor, $v_devminor, $v_prefix, &#039;&#039;);

        // ----- Calculate the checksum
        $v_checksum = 0;
        // ..... First part of the header
        for ($i=0; $i&lt;148; $i++)
            $v_checksum += ord(substr($v_binary_data_first,$i,1));
        // ..... Ignore the checksum value and replace it by &#039; &#039; (space)
        for ($i=148; $i&lt;156; $i++)
            $v_checksum += ord(&#039; &#039;);
        // ..... Last part of the header
        for ($i=156, $j=0; $i&lt;512; $i++, $j++)
            $v_checksum += ord(substr($v_binary_data_last,$j,1));

        // ----- Write the first 148 bytes of the header in the archive
        $this-&gt;_writeBlock($v_binary_data_first, 148);

        // ----- Write the calculated checksum
        $v_checksum = sprintf(&quot;%06s &quot;, DecOct($v_checksum));
        $v_binary_data = pack(&quot;a8&quot;, $v_checksum);
        $this-&gt;_writeBlock($v_binary_data, 8);

        // ----- Write the last 356 bytes of the header in the archive
        $this-&gt;_writeBlock($v_binary_data_last, 356);

        return true;
    }
    // }}}

    // {{{ _writeHeaderBlock()
    function _writeHeaderBlock($p_filename, $p_size, $p_mtime=0, $p_perms=0,
	                           $p_type=&#039;&#039;, $p_uid=0, $p_gid=0)
    {
        $p_filename = $this-&gt;_pathReduction($p_filename);

        if (strlen($p_filename) &gt; 99) {
          if (!$this-&gt;_writeLongHeader($p_filename))
            return false;
        }

        if ($p_type == &quot;5&quot;) {
          $v_size = sprintf(&quot;%011s&quot;, DecOct(0));
        } else {
          $v_size = sprintf(&quot;%011s&quot;, DecOct($p_size));
        }

        $v_uid = sprintf(&quot;%07s&quot;, DecOct($p_uid));
        $v_gid = sprintf(&quot;%07s&quot;, DecOct($p_gid));
        $v_perms = sprintf(&quot;%07s&quot;, DecOct($p_perms &amp; 000777));

        $v_mtime = sprintf(&quot;%11s&quot;, DecOct($p_mtime));

        $v_linkname = &#039;&#039;;

        $v_magic = &#039;ustar &#039;;

        $v_version = &#039; &#039;;

        if (function_exists(&#039;posix_getpwuid&#039;))
        {
          $userinfo = posix_getpwuid($p_uid);
          $groupinfo = posix_getgrgid($p_gid);
          
          $v_uname = $userinfo[&#039;name&#039;];
          $v_gname = $groupinfo[&#039;name&#039;];
        }
        else
        {
          $v_uname = &#039;&#039;;
          $v_gname = &#039;&#039;;
        }
        
        $v_devmajor = &#039;&#039;;

        $v_devminor = &#039;&#039;;

        $v_prefix = &#039;&#039;;

        $v_binary_data_first = pack(&quot;a100a8a8a8a12A12&quot;,
		                            $p_filename, $v_perms, $v_uid, $v_gid,
									$v_size, $v_mtime);
        $v_binary_data_last = pack(&quot;a1a100a6a2a32a32a8a8a155a12&quot;,
		                           $p_type, $v_linkname, $v_magic,
								   $v_version, $v_uname, $v_gname,
								   $v_devmajor, $v_devminor, $v_prefix, &#039;&#039;);

        // ----- Calculate the checksum
        $v_checksum = 0;
        // ..... First part of the header
        for ($i=0; $i&lt;148; $i++)
            $v_checksum += ord(substr($v_binary_data_first,$i,1));
        // ..... Ignore the checksum value and replace it by &#039; &#039; (space)
        for ($i=148; $i&lt;156; $i++)
            $v_checksum += ord(&#039; &#039;);
        // ..... Last part of the header
        for ($i=156, $j=0; $i&lt;512; $i++, $j++)
            $v_checksum += ord(substr($v_binary_data_last,$j,1));

        // ----- Write the first 148 bytes of the header in the archive
        $this-&gt;_writeBlock($v_binary_data_first, 148);

        // ----- Write the calculated checksum
        $v_checksum = sprintf(&quot;%06s &quot;, DecOct($v_checksum));
        $v_binary_data = pack(&quot;a8&quot;, $v_checksum);
        $this-&gt;_writeBlock($v_binary_data, 8);

        // ----- Write the last 356 bytes of the header in the archive
        $this-&gt;_writeBlock($v_binary_data_last, 356);

        return true;
    }
    // }}}

    // {{{ _writeLongHeader()
    function _writeLongHeader($p_filename)
    {
        $v_size = sprintf(&quot;%11s &quot;, DecOct(strlen($p_filename)));

        $v_typeflag = &#039;L&#039;;

        $v_linkname = &#039;&#039;;

        $v_magic = &#039;&#039;;

        $v_version = &#039;&#039;;

        $v_uname = &#039;&#039;;

        $v_gname = &#039;&#039;;

        $v_devmajor = &#039;&#039;;

        $v_devminor = &#039;&#039;;

        $v_prefix = &#039;&#039;;

        $v_binary_data_first = pack(&quot;a100a8a8a8a12a12&quot;,
		                            &#039;././@LongLink&#039;, 0, 0, 0, $v_size, 0);
        $v_binary_data_last = pack(&quot;a1a100a6a2a32a32a8a8a155a12&quot;,
		                           $v_typeflag, $v_linkname, $v_magic,
								   $v_version, $v_uname, $v_gname,
								   $v_devmajor, $v_devminor, $v_prefix, &#039;&#039;);

        // ----- Calculate the checksum
        $v_checksum = 0;
        // ..... First part of the header
        for ($i=0; $i&lt;148; $i++)
            $v_checksum += ord(substr($v_binary_data_first,$i,1));
        // ..... Ignore the checksum value and replace it by &#039; &#039; (space)
        for ($i=148; $i&lt;156; $i++)
            $v_checksum += ord(&#039; &#039;);
        // ..... Last part of the header
        for ($i=156, $j=0; $i&lt;512; $i++, $j++)
            $v_checksum += ord(substr($v_binary_data_last,$j,1));

        // ----- Write the first 148 bytes of the header in the archive
        $this-&gt;_writeBlock($v_binary_data_first, 148);

        // ----- Write the calculated checksum
        $v_checksum = sprintf(&quot;%06s &quot;, DecOct($v_checksum));
        $v_binary_data = pack(&quot;a8&quot;, $v_checksum);
        $this-&gt;_writeBlock($v_binary_data, 8);

        // ----- Write the last 356 bytes of the header in the archive
        $this-&gt;_writeBlock($v_binary_data_last, 356);

        // ----- Write the filename as content of the block
        $i=0;
        while (($v_buffer = substr($p_filename, (($i++)*512), 512)) != &#039;&#039;) {
            $v_binary_data = pack(&quot;a512&quot;, &quot;$v_buffer&quot;);
            $this-&gt;_writeBlock($v_binary_data);
        }

        return true;
    }
    // }}}

    // {{{ _readHeader()
    function _readHeader($v_binary_data, &amp;$v_header)
    {
        if (strlen($v_binary_data)==0) {
            $v_header[&#039;filename&#039;] = &#039;&#039;;
            return true;
        }

        if (strlen($v_binary_data) != 512) {
            $v_header[&#039;filename&#039;] = &#039;&#039;;
            $this-&gt;_error(&#039;Invalid block size : &#039;.strlen($v_binary_data));
            return false;
        }

        if (!is_array($v_header)) {
            $v_header = array();
        }
        // ----- Calculate the checksum
        $v_checksum = 0;
        // ..... First part of the header
        for ($i=0; $i&lt;148; $i++)
            $v_checksum+=ord(substr($v_binary_data,$i,1));
        // ..... Ignore the checksum value and replace it by &#039; &#039; (space)
        for ($i=148; $i&lt;156; $i++)
            $v_checksum += ord(&#039; &#039;);
        // ..... Last part of the header
        for ($i=156; $i&lt;512; $i++)
           $v_checksum+=ord(substr($v_binary_data,$i,1));

        $v_data = unpack(&quot;a100filename/a8mode/a8uid/a8gid/a12size/a12mtime/&quot;
		                 .&quot;a8checksum/a1typeflag/a100link/a6magic/a2version/&quot;
						 .&quot;a32uname/a32gname/a8devmajor/a8devminor&quot;,
						 $v_binary_data);

        // ----- Extract the checksum
        $v_header[&#039;checksum&#039;] = OctDec(trim($v_data[&#039;checksum&#039;]));
        if ($v_header[&#039;checksum&#039;] != $v_checksum) {
            $v_header[&#039;filename&#039;] = &#039;&#039;;

            // ----- Look for last block (empty block)
            if (($v_checksum == 256) &amp;&amp; ($v_header[&#039;checksum&#039;] == 0))
                return true;

            $this-&gt;_error(&#039;Invalid checksum for file &quot;&#039;.$v_data[&#039;filename&#039;]
			              .&#039;&quot; : &#039;.$v_checksum.&#039; calculated, &#039;
						  .$v_header[&#039;checksum&#039;].&#039; expected&#039;);
            return false;
        }

        // ----- Extract the properties
        $v_header[&#039;filename&#039;] = $v_data[&#039;filename&#039;];
        if ($this-&gt;_maliciousFilename($v_header[&#039;filename&#039;])) {
            $this-&gt;_error(&#039;Malicious .tar detected, file &quot;&#039; . $v_header[&#039;filename&#039;] .
                &#039;&quot; will not install in desired directory tree&#039;);
            return false;
        }
        $v_header[&#039;mode&#039;] = OctDec(trim($v_data[&#039;mode&#039;]));
        $v_header[&#039;uid&#039;] = OctDec(trim($v_data[&#039;uid&#039;]));
        $v_header[&#039;gid&#039;] = OctDec(trim($v_data[&#039;gid&#039;]));
        $v_header[&#039;size&#039;] = OctDec(trim($v_data[&#039;size&#039;]));
        $v_header[&#039;mtime&#039;] = OctDec(trim($v_data[&#039;mtime&#039;]));
        if (($v_header[&#039;typeflag&#039;] = $v_data[&#039;typeflag&#039;]) == &quot;5&quot;) {
          $v_header[&#039;size&#039;] = 0;
        }
        $v_header[&#039;link&#039;] = trim($v_data[&#039;link&#039;]);
        /* ----- All these fields are removed form the header because
		they do not carry interesting info
        $v_header[magic] = trim($v_data[magic]);
        $v_header[version] = trim($v_data[version]);
        $v_header[uname] = trim($v_data[uname]);
        $v_header[gname] = trim($v_data[gname]);
        $v_header[devmajor] = trim($v_data[devmajor]);
        $v_header[devminor] = trim($v_data[devminor]);
        */

        return true;
    }
    // }}}

    // {{{ _maliciousFilename()
    /**
     * Detect and report a malicious file name
     *
     * @param string $file
     * @return bool
     * @access private
     */
    function _maliciousFilename($file)
    {
        if (strpos($file, &#039;/../&#039;) !== false) {
            return true;
        }
        if (strpos($file, &#039;../&#039;) === 0) {
            return true;
        }
        return false;
    }
    // }}}

    // {{{ _readLongHeader()
    function _readLongHeader(&amp;$v_header)
    {
      $v_filename = &#039;&#039;;
      $n = floor($v_header[&#039;size&#039;]/512);
      for ($i=0; $i&lt;$n; $i++) {
        $v_content = $this-&gt;_readBlock();
        $v_filename .= $v_content;
      }
      if (($v_header[&#039;size&#039;] % 512) != 0) {
        $v_content = $this-&gt;_readBlock();
        $v_filename .= trim($v_content);
      }

      // ----- Read the next header
      $v_binary_data = $this-&gt;_readBlock();

      if (!$this-&gt;_readHeader($v_binary_data, $v_header))
        return false;

      $v_filename = trim($v_filename);
      $v_header[&#039;filename&#039;] = $v_filename;
        if ($this-&gt;_maliciousFilename($v_filename)) {
            $this-&gt;_error(&#039;Malicious .tar detected, file &quot;&#039; . $v_filename .
                &#039;&quot; will not install in desired directory tree&#039;);
            return false;
      }

      return true;
    }
    // }}}

    // {{{ _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 private
    */
    function _extractInString($p_filename)
    {
        $v_result_str = &quot;&quot;;

        While (strlen($v_binary_data = $this-&gt;_readBlock()) != 0)
        {
          if (!$this-&gt;_readHeader($v_binary_data, $v_header))
            return NULL;

          if ($v_header[&#039;filename&#039;] == &#039;&#039;)
            continue;

          // ----- Look for long filename
          if ($v_header[&#039;typeflag&#039;] == &#039;L&#039;) {
            if (!$this-&gt;_readLongHeader($v_header))
              return NULL;
          }

          if ($v_header[&#039;filename&#039;] == $p_filename) {
              if ($v_header[&#039;typeflag&#039;] == &quot;5&quot;) {
                  $this-&gt;_error(&#039;Unable to extract in string a directory &#039;
				                .&#039;entry {&#039;.$v_header[&#039;filename&#039;].&#039;}&#039;);
                  return NULL;
              } else {
                  $n = floor($v_header[&#039;size&#039;]/512);
                  for ($i=0; $i&lt;$n; $i++) {
                      $v_result_str .= $this-&gt;_readBlock();
                  }
                  if (($v_header[&#039;size&#039;] % 512) != 0) {
                      $v_content = $this-&gt;_readBlock();
                      $v_result_str .= substr($v_content, 0,
					                          ($v_header[&#039;size&#039;] % 512));
                  }
                  return $v_result_str;
              }
          } else {
              $this-&gt;_jumpBlock(ceil(($v_header[&#039;size&#039;]/512)));
          }
        }

        return NULL;
    }
    // }}}

    // {{{ _extractList()
    function _extractList($p_path, &amp;$p_list_detail, $p_mode,
	                      $p_file_list, $p_remove_path)
    {
    $v_result=true;
    $v_nb = 0;
    $v_extract_all = true;
    $v_listing = false;

    $p_path = $this-&gt;_translateWinPath($p_path, false);
    if ($p_path == &#039;&#039; || (substr($p_path, 0, 1) != &#039;/&#039;
	    &amp;&amp; substr($p_path, 0, 3) != &quot;../&quot; &amp;&amp; !strpos($p_path, &#039;:&#039;))) {
      $p_path = &quot;./&quot;.$p_path;
    }
    $p_remove_path = $this-&gt;_translateWinPath($p_remove_path);

    // ----- Look for path to remove format (should end by /)
    if (($p_remove_path != &#039;&#039;) &amp;&amp; (substr($p_remove_path, -1) != &#039;/&#039;))
      $p_remove_path .= &#039;/&#039;;
    $p_remove_path_size = strlen($p_remove_path);

    switch ($p_mode) {
      case &quot;complete&quot; :
        $v_extract_all = TRUE;
        $v_listing = FALSE;
      break;
      case &quot;partial&quot; :
          $v_extract_all = FALSE;
          $v_listing = FALSE;
      break;
      case &quot;list&quot; :
          $v_extract_all = FALSE;
          $v_listing = TRUE;
      break;
      default :
        $this-&gt;_error(&#039;Invalid extract mode (&#039;.$p_mode.&#039;)&#039;);
        return false;
    }

    clearstatcache();

    while (strlen($v_binary_data = $this-&gt;_readBlock()) != 0)
    {
      $v_extract_file = FALSE;
      $v_extraction_stopped = 0;

      if (!$this-&gt;_readHeader($v_binary_data, $v_header))
        return false;

      if ($v_header[&#039;filename&#039;] == &#039;&#039;) {
        continue;
      }

      // ----- Look for long filename
      if ($v_header[&#039;typeflag&#039;] == &#039;L&#039;) {
        if (!$this-&gt;_readLongHeader($v_header))
          return false;
      }

      if ((!$v_extract_all) &amp;&amp; (is_array($p_file_list))) {
        // ----- By default no unzip if the file is not found
        $v_extract_file = false;

        for ($i=0; $i&lt;sizeof($p_file_list); $i++) {
          // ----- Look if it is a directory
          if (substr($p_file_list[$i], -1) == &#039;/&#039;) {
            // ----- Look if the directory is in the filename path
            if ((strlen($v_header[&#039;filename&#039;]) &gt; strlen($p_file_list[$i]))
			    &amp;&amp; (substr($v_header[&#039;filename&#039;], 0, strlen($p_file_list[$i]))
				    == $p_file_list[$i])) {
              $v_extract_file = TRUE;
              break;
            }
          }

          // ----- It is a file, so compare the file names
          elseif ($p_file_list[$i] == $v_header[&#039;filename&#039;]) {
            $v_extract_file = TRUE;
            break;
          }
        }
      } else {
        $v_extract_file = TRUE;
      }

      // ----- Look if this file need to be extracted
      if (($v_extract_file) &amp;&amp; (!$v_listing))
      {
        if (($p_remove_path != &#039;&#039;)
            &amp;&amp; (substr($v_header[&#039;filename&#039;], 0, $p_remove_path_size)
			    == $p_remove_path))
          $v_header[&#039;filename&#039;] = substr($v_header[&#039;filename&#039;],
		                                 $p_remove_path_size);
        if (($p_path != &#039;./&#039;) &amp;&amp; ($p_path != &#039;/&#039;)) {
          while (substr($p_path, -1) == &#039;/&#039;)
            $p_path = substr($p_path, 0, strlen($p_path)-1);

          if (substr($v_header[&#039;filename&#039;], 0, 1) == &#039;/&#039;)
              $v_header[&#039;filename&#039;] = $p_path.$v_header[&#039;filename&#039;];
          else
            $v_header[&#039;filename&#039;] = $p_path.&#039;/&#039;.$v_header[&#039;filename&#039;];
        }
        if (file_exists($v_header[&#039;filename&#039;])) {
          if (   (@is_dir($v_header[&#039;filename&#039;]))
		      &amp;&amp; ($v_header[&#039;typeflag&#039;] == &#039;&#039;)) {
            $this-&gt;_error(&#039;File &#039;.$v_header[&#039;filename&#039;]
			              .&#039; already exists as a directory&#039;);
            return false;
          }
          if (   ($this-&gt;_isArchive($v_header[&#039;filename&#039;]))
		      &amp;&amp; ($v_header[&#039;typeflag&#039;] == &quot;5&quot;)) {
            $this-&gt;_error(&#039;Directory &#039;.$v_header[&#039;filename&#039;]
			              .&#039; already exists as a file&#039;);
            return false;
          }
          if (!is_writeable($v_header[&#039;filename&#039;])) {
            $this-&gt;_error(&#039;File &#039;.$v_header[&#039;filename&#039;]
			              .&#039; already exists and is write protected&#039;);
            return false;
          }
          if (filemtime($v_header[&#039;filename&#039;]) &gt; $v_header[&#039;mtime&#039;]) {
            // To be completed : An error or silent no replace ?
          }
        }

        // ----- Check the directory availability and create it if necessary
        elseif (($v_result
		         = $this-&gt;_dirCheck(($v_header[&#039;typeflag&#039;] == &quot;5&quot;
				                    ?$v_header[&#039;filename&#039;]
									:dirname($v_header[&#039;filename&#039;])))) != 1) {
            $this-&gt;_error(&#039;Unable to create path for &#039;.$v_header[&#039;filename&#039;]);
            return false;
        }

        if ($v_extract_file) {
          if ($v_header[&#039;typeflag&#039;] == &quot;5&quot;) {
            if (!@file_exists($v_header[&#039;filename&#039;])) {
                if (!@mkdir($v_header[&#039;filename&#039;], 0777)) {
                    $this-&gt;_error(&#039;Unable to create directory {&#039;
					              .$v_header[&#039;filename&#039;].&#039;}&#039;);
                    return false;
                }
            }
          } elseif ($v_header[&#039;typeflag&#039;] == &quot;2&quot;) {
              if (@file_exists($v_header[&#039;filename&#039;])) {
                  @unlink($v_header[&#039;filename&#039;]);
              }
              if (!@symlink($v_header[&#039;link&#039;], $v_header[&#039;filename&#039;])) {
                  $this-&gt;_error(&#039;Unable to extract symbolic link {&#039;
                                .$v_header[&#039;filename&#039;].&#039;}&#039;);
                  return false;
              }
          } else {
              if (($v_dest_file = @fopen($v_header[&#039;filename&#039;], &quot;wb&quot;)) == 0) {
                  $this-&gt;_error(&#039;Error while opening {&#039;.$v_header[&#039;filename&#039;]
				                .&#039;} in write binary mode&#039;);
                  return false;
              } else {
                  $n = floor($v_header[&#039;size&#039;]/512);
                  for ($i=0; $i&lt;$n; $i++) {
                      $v_content = $this-&gt;_readBlock();
                      fwrite($v_dest_file, $v_content, 512);
                  }
            if (($v_header[&#039;size&#039;] % 512) != 0) {
              $v_content = $this-&gt;_readBlock();
              fwrite($v_dest_file, $v_content, ($v_header[&#039;size&#039;] % 512));
            }

            @fclose($v_dest_file);

            // ----- Change the file mode, mtime
            @touch($v_header[&#039;filename&#039;], $v_header[&#039;mtime&#039;]);
            if ($v_header[&#039;mode&#039;] &amp; 0111) {
                // make file executable, obey umask
                $mode = fileperms($v_header[&#039;filename&#039;]) | (~umask() &amp; 0111);
                @chmod($v_header[&#039;filename&#039;], $mode);
            }
          }

          // ----- Check the file size
          clearstatcache();
          if (filesize($v_header[&#039;filename&#039;]) != $v_header[&#039;size&#039;]) {
              $this-&gt;_error(&#039;Extracted file &#039;.$v_header[&#039;filename&#039;]
			                .&#039; does not have the correct file size \&#039;&#039;
							.filesize($v_header[&#039;filename&#039;])
							.&#039;\&#039; (&#039;.$v_header[&#039;size&#039;]
							.&#039; expected). Archive may be corrupted.&#039;);
              return false;
          }
          }
        } else {
          $this-&gt;_jumpBlock(ceil(($v_header[&#039;size&#039;]/512)));
        }
      } else {
          $this-&gt;_jumpBlock(ceil(($v_header[&#039;size&#039;]/512)));
      }

      /* TBC : Seems to be unused ...
      if ($this-&gt;_compress)
        $v_end_of_file = @gzeof($this-&gt;_file);
      else
        $v_end_of_file = @feof($this-&gt;_file);
        */

      if ($v_listing || $v_extract_file || $v_extraction_stopped) {
        // ----- Log extracted files
        if (($v_file_dir = dirname($v_header[&#039;filename&#039;]))
		    == $v_header[&#039;filename&#039;])
          $v_file_dir = &#039;&#039;;
        if ((substr($v_header[&#039;filename&#039;], 0, 1) == &#039;/&#039;) &amp;&amp; ($v_file_dir == &#039;&#039;))
          $v_file_dir = &#039;/&#039;;

        $p_list_detail[$v_nb++] = $v_header;
        if (is_array($p_file_list) &amp;&amp; (count($p_list_detail) == count($p_file_list))) {
            return true;
        }
      }
    }

        return true;
    }
    // }}}

    // {{{ _openAppend()
    function _openAppend()
    {
        if (filesize($this-&gt;_tarname) == 0)
          return $this-&gt;_openWrite();

        if ($this-&gt;_compress) {
            $this-&gt;_close();

            if (!@rename($this-&gt;_tarname, $this-&gt;_tarname.&quot;.tmp&quot;)) {
                $this-&gt;_error(&#039;Error while renaming \&#039;&#039;.$this-&gt;_tarname
				              .&#039;\&#039; to temporary file \&#039;&#039;.$this-&gt;_tarname
							  .&#039;.tmp\&#039;&#039;);
                return false;
            }

            if ($this-&gt;_compress_type == &#039;gz&#039;)
                $v_temp_tar = @gzopen($this-&gt;_tarname.&quot;.tmp&quot;, &quot;rb&quot;);
            elseif ($this-&gt;_compress_type == &#039;bz2&#039;)
                $v_temp_tar = @bzopen($this-&gt;_tarname.&quot;.tmp&quot;, &quot;r&quot;);

            if ($v_temp_tar == 0) {
                $this-&gt;_error(&#039;Unable to open file \&#039;&#039;.$this-&gt;_tarname
				              .&#039;.tmp\&#039; in binary read mode&#039;);
                @rename($this-&gt;_tarname.&quot;.tmp&quot;, $this-&gt;_tarname);
                return false;
            }

            if (!$this-&gt;_openWrite()) {
                @rename($this-&gt;_tarname.&quot;.tmp&quot;, $this-&gt;_tarname);
                return false;
            }

            if ($this-&gt;_compress_type == &#039;gz&#039;) {
                while (!@gzeof($v_temp_tar)) {
                    $v_buffer = @gzread($v_temp_tar, 512);
                    if ($v_buffer == ARCHIVE_TAR_END_BLOCK) {
                        // do not copy end blocks, we will re-make them
                        // after appending
                        continue;
                    }
                    $v_binary_data = pack(&quot;a512&quot;, $v_buffer);
                    $this-&gt;_writeBlock($v_binary_data);
                }

                @gzclose($v_temp_tar);
            }
            elseif ($this-&gt;_compress_type == &#039;bz2&#039;) {
                while (strlen($v_buffer = @bzread($v_temp_tar, 512)) &gt; 0) {
                    if ($v_buffer == ARCHIVE_TAR_END_BLOCK) {
                        continue;
                    }
                    $v_binary_data = pack(&quot;a512&quot;, $v_buffer);
                    $this-&gt;_writeBlock($v_binary_data);
                }

                @bzclose($v_temp_tar);
            }

            if (!@unlink($this-&gt;_tarname.&quot;.tmp&quot;)) {
                $this-&gt;_error(&#039;Error while deleting temporary file \&#039;&#039;
				              .$this-&gt;_tarname.&#039;.tmp\&#039;&#039;);
            }

        } else {
            // ----- For not compressed tar, just add files before the last
			//       one or two 512 bytes block
            if (!$this-&gt;_openReadWrite())
               return false;

            clearstatcache();
            $v_size = filesize($this-&gt;_tarname);

            // We might have zero, one or two end blocks.
            // The standard is two, but we should try to handle
            // other cases.
            fseek($this-&gt;_file, $v_size - 1024);
            if (fread($this-&gt;_file, 512) == ARCHIVE_TAR_END_BLOCK) {
                fseek($this-&gt;_file, $v_size - 1024);
            }
            elseif (fread($this-&gt;_file, 512) == ARCHIVE_TAR_END_BLOCK) {
                fseek($this-&gt;_file, $v_size - 512);
            }
        }

        return true;
    }
    // }}}

    // {{{ _append()
    function _append($p_filelist, $p_add_dir=&#039;&#039;, $p_remove_dir=&#039;&#039;)
    {
        if (!$this-&gt;_openAppend())
            return false;

        if ($this-&gt;_addList($p_filelist, $p_add_dir, $p_remove_dir))
           $this-&gt;_writeFooter();

        $this-&gt;_close();

        return true;
    }
    // }}}

    // {{{ _dirCheck()

    /**
     * Check if a directory exists and create it (including parent
     * dirs) if not.
     *
     * @param string $p_dir directory to check
     *
     * @return bool TRUE if the directory exists or was created
     */
    function _dirCheck($p_dir)
    {
        clearstatcache();
        if ((@is_dir($p_dir)) || ($p_dir == &#039;&#039;))
            return true;

        $p_parent_dir = dirname($p_dir);

        if (($p_parent_dir != $p_dir) &amp;&amp;
            ($p_parent_dir != &#039;&#039;) &amp;&amp;
            (!$this-&gt;_dirCheck($p_parent_dir)))
             return false;

        if (!@mkdir($p_dir, 0777)) {
            $this-&gt;_error(&quot;Unable to create directory &#039;$p_dir&#039;&quot;);
            return false;
        }

        return true;
    }

    // }}}

    // {{{ _pathReduction()

    /**
     * Compress path by changing for example &quot;/dir/foo/../bar&quot; to &quot;/dir/bar&quot;,
     * rand emove double slashes.
     *
     * @param string $p_dir path to reduce
     *
     * @return string reduced path
     *
     * @access private
     *
     */
    function _pathReduction($p_dir)
    {
        $v_result = &#039;&#039;;

        // ----- Look for not empty path
        if ($p_dir != &#039;&#039;) {
            // ----- Explode path by directory names
            $v_list = explode(&#039;/&#039;, $p_dir);

            // ----- Study directories from last to first
            for ($i=sizeof($v_list)-1; $i&gt;=0; $i--) {
                // ----- Look for current path
                if ($v_list[$i] == &quot;.&quot;) {
                    // ----- Ignore this directory
                    // Should be the first $i=0, but no check is done
                }
                else if ($v_list[$i] == &quot;..&quot;) {
                    // ----- Ignore it and ignore the $i-1
                    $i--;
                }
                else if (   ($v_list[$i] == &#039;&#039;)
				         &amp;&amp; ($i!=(sizeof($v_list)-1))
						 &amp;&amp; ($i!=0)) {
                    // ----- Ignore only the double &#039;//&#039; in path,
                    // but not the first and last /
                } else {
                    $v_result = $v_list[$i].($i!=(sizeof($v_list)-1)?&#039;/&#039;
					            .$v_result:&#039;&#039;);
                }
            }
        }
        $v_result = strtr($v_result, &#039;\\&#039;, &#039;/&#039;);
        return $v_result;
    }

    // }}}

    // {{{ _translateWinPath()
    function _translateWinPath($p_path, $p_remove_disk_letter=true)
    {
      if (defined(&#039;OS_WINDOWS&#039;) &amp;&amp; OS_WINDOWS) {
          // ----- Look for potential disk letter
          if (   ($p_remove_disk_letter)
		      &amp;&amp; (($v_position = strpos($p_path, &#039;:&#039;)) != false)) {
              $p_path = substr($p_path, $v_position+1);
          }
          // ----- Change potential windows directory separator
          if ((strpos($p_path, &#039;\\&#039;) &gt; 0) || (substr($p_path, 0,1) == &#039;\\&#039;)) {
              $p_path = strtr($p_path, &#039;\\&#039;, &#039;/&#039;);
          }
      }
      return $p_path;
    }
    // }}}

}
?&gt;
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2F4xpips.net%2Fsecure%2Flibrary%2Fpear%2FArchive'>⬅ Back to Directory</a>