<h2>Edit File - Installer.php</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/opt/alt/php71/usr/share/pear/PEAR/Installer.php">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&lt;?php
/**
 * PEAR_Installer
 *
 * PHP versions 4 and 5
 *
 * @category   pear
 * @package    PEAR
 * @author     Stig Bakken &lt;ssb@php.net&gt;
 * @author     Tomas V.V. Cox &lt;cox@idecnet.com&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Greg Beaver &lt;cellog@php.net&gt;
 * @copyright  1997-2009 The Authors
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 * @link       http://pear.php.net/package/PEAR
 * @since      File available since Release 0.1
 */

/**
 * Used for installation groups in package.xml 2.0 and platform exceptions
 */
require_once &#039;OS/Guess.php&#039;;
require_once &#039;PEAR/Downloader.php&#039;;

define(&#039;PEAR_INSTALLER_NOBINARY&#039;, -240);
/**
 * Administration class used to install PEAR packages and maintain the
 * installed package database.
 *
 * @category   pear
 * @package    PEAR
 * @author     Stig Bakken &lt;ssb@php.net&gt;
 * @author     Tomas V.V. Cox &lt;cox@idecnet.com&gt;
 * @author     Martin Jansen &lt;mj@php.net&gt;
 * @author     Greg Beaver &lt;cellog@php.net&gt;
 * @copyright  1997-2009 The Authors
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 * @version    Release: 1.10.16
 * @link       http://pear.php.net/package/PEAR
 * @since      Class available since Release 0.1
 */
class PEAR_Installer extends PEAR_Downloader
{
    // {{{ properties

    /** name of the package directory, for example Foo-1.0
     * @var string
     */
    var $pkgdir;

    /** directory where PHP code files go
     * @var string
     */
    var $phpdir;

    /** directory where PHP extension files go
     * @var string
     */
    var $extdir;

    /** directory where documentation goes
     * @var string
     */
    var $docdir;

    /** installation root directory (ala PHP&#039;s INSTALL_ROOT or
     * automake&#039;s DESTDIR
     * @var string
     */
    var $installroot = &#039;&#039;;

    /** debug level
     * @var int
     */
    var $debug = 1;

    /** temporary directory
     * @var string
     */
    var $tmpdir;

    /**
     * PEAR_Registry object used by the installer
     * @var PEAR_Registry
     */
    var $registry;

    /**
     * array of PEAR_Downloader_Packages
     * @var array
     */
    var $_downloadedPackages;

    /** List of file transactions queued for an install/upgrade/uninstall.
     *
     *  Format:
     *    array(
     *      0 =&gt; array(&quot;rename =&gt; array(&quot;from-file&quot;, &quot;to-file&quot;)),
     *      1 =&gt; array(&quot;delete&quot; =&gt; array(&quot;file-to-delete&quot;)),
     *      ...
     *    )
     *
     * @var array
     */
    var $file_operations = array();

    // }}}

    // {{{ constructor

    /**
     * PEAR_Installer constructor.
     *
     * @param object $ui user interface object (instance of PEAR_Frontend_*)
     *
     * @access public
     */
    function __construct(&amp;$ui)
    {
        parent::__construct($ui, array(), null);
        $this-&gt;setFrontendObject($ui);
        $this-&gt;debug = $this-&gt;config-&gt;get(&#039;verbose&#039;);
    }

    function setOptions($options)
    {
        $this-&gt;_options = $options;
    }

    function setConfig(&amp;$config)
    {
        $this-&gt;config    = &amp;$config;
        $this-&gt;_registry = &amp;$config-&gt;getRegistry();
    }

    // }}}

    function _removeBackups($files)
    {
        foreach ($files as $path) {
            $this-&gt;addFileOperation(&#039;removebackup&#039;, array($path));
        }
    }

    // {{{ _deletePackageFiles()

    /**
     * Delete a package&#039;s installed files, does not remove empty directories.
     *
     * @param string package name
     * @param string channel name
     * @param bool if true, then files are backed up first
     * @return bool TRUE on success, or a PEAR error on failure
     * @access protected
     */
    function _deletePackageFiles($package, $channel = false, $backup = false)
    {
        if (!$channel) {
            $channel = &#039;pear.php.net&#039;;
        }

        if (!strlen($package)) {
            return $this-&gt;raiseError(&quot;No package to uninstall given&quot;);
        }

        if (strtolower($package) == &#039;pear&#039; &amp;&amp; $channel == &#039;pear.php.net&#039;) {
            // to avoid race conditions, include all possible needed files
            require_once &#039;PEAR/Task/Common.php&#039;;
            require_once &#039;PEAR/Task/Replace.php&#039;;
            require_once &#039;PEAR/Task/Unixeol.php&#039;;
            require_once &#039;PEAR/Task/Windowseol.php&#039;;
            require_once &#039;PEAR/PackageFile/v1.php&#039;;
            require_once &#039;PEAR/PackageFile/v2.php&#039;;
            require_once &#039;PEAR/PackageFile/Generator/v1.php&#039;;
            require_once &#039;PEAR/PackageFile/Generator/v2.php&#039;;
        }

        $filelist = $this-&gt;_registry-&gt;packageInfo($package, &#039;filelist&#039;, $channel);
        if ($filelist == null) {
            return $this-&gt;raiseError(&quot;$channel/$package not installed&quot;);
        }

        $ret = array();
        foreach ($filelist as $file =&gt; $props) {
            if (empty($props[&#039;installed_as&#039;])) {
                continue;
            }

            $path = $props[&#039;installed_as&#039;];
            if ($backup) {
                $this-&gt;addFileOperation(&#039;backup&#039;, array($path));
                $ret[] = $path;
            }

            $this-&gt;addFileOperation(&#039;delete&#039;, array($path));
        }

        if ($backup) {
            return $ret;
        }

        return true;
    }

    // }}}
    // {{{ _installFile()

    /**
     * @param string filename
     * @param array attributes from &lt;file&gt; tag in package.xml
     * @param string path to install the file in
     * @param array options from command-line
     * @access private
     */
    function _installFile($file, $atts, $tmp_path, $options)
    {
        // {{{ return if this file is meant for another platform
        static $os;
        if (!isset($this-&gt;_registry)) {
            $this-&gt;_registry = &amp;$this-&gt;config-&gt;getRegistry();
        }

        if (isset($atts[&#039;platform&#039;])) {
            if (empty($os)) {
                $os = new OS_Guess();
            }

            if (strlen($atts[&#039;platform&#039;]) &amp;&amp; $atts[&#039;platform&#039;][0] == &#039;!&#039;) {
                $negate   = true;
                $platform = substr($atts[&#039;platform&#039;], 1);
            } else {
                $negate    = false;
                $platform = $atts[&#039;platform&#039;];
            }

            if ((bool) $os-&gt;matchSignature($platform) === $negate) {
                $this-&gt;log(3, &quot;skipped $file (meant for $atts[platform], we are &quot;.$os-&gt;getSignature().&quot;)&quot;);
                return PEAR_INSTALLER_SKIPPED;
            }
        }
        // }}}

        $channel = $this-&gt;pkginfo-&gt;getChannel();
        // {{{ assemble the destination paths
        switch ($atts[&#039;role&#039;]) {
            case &#039;src&#039;:
            case &#039;extsrc&#039;:
                $this-&gt;source_files++;
                return;
            case &#039;doc&#039;:
            case &#039;data&#039;:
            case &#039;test&#039;:
                $dest_dir = $this-&gt;config-&gt;get($atts[&#039;role&#039;] . &#039;_dir&#039;, null, $channel) .
                            DIRECTORY_SEPARATOR . $this-&gt;pkginfo-&gt;getPackage();
                unset($atts[&#039;baseinstalldir&#039;]);
                break;
            case &#039;ext&#039;:
            case &#039;php&#039;:
                $dest_dir = $this-&gt;config-&gt;get($atts[&#039;role&#039;] . &#039;_dir&#039;, null, $channel);
                break;
            case &#039;script&#039;:
                $dest_dir = $this-&gt;config-&gt;get(&#039;bin_dir&#039;, null, $channel);
                break;
            default:
                return $this-&gt;raiseError(&quot;Invalid role `$atts[role]&#039; for file $file&quot;);
        }

        $save_destdir = $dest_dir;
        if (!empty($atts[&#039;baseinstalldir&#039;])) {
            $dest_dir .= DIRECTORY_SEPARATOR . $atts[&#039;baseinstalldir&#039;];
        }

        if (dirname($file) != &#039;.&#039; &amp;&amp; empty($atts[&#039;install-as&#039;])) {
            $dest_dir .= DIRECTORY_SEPARATOR . dirname($file);
        }

        if (empty($atts[&#039;install-as&#039;])) {
            $dest_file = $dest_dir . DIRECTORY_SEPARATOR . basename($file);
        } else {
            $dest_file = $dest_dir . DIRECTORY_SEPARATOR . $atts[&#039;install-as&#039;];
        }
        $orig_file = $tmp_path . DIRECTORY_SEPARATOR . $file;

        // Clean up the DIRECTORY_SEPARATOR mess
        $ds2 = DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR;
        list($dest_file, $orig_file) = preg_replace(array(&#039;!\\\\+!&#039;, &#039;!/!&#039;, &quot;!$ds2+!&quot;),
                                                    array(DIRECTORY_SEPARATOR,
                                                          DIRECTORY_SEPARATOR,
                                                          DIRECTORY_SEPARATOR),
                                                    array($dest_file, $orig_file));
        $final_dest_file = $installed_as = $dest_file;
        if (isset($this-&gt;_options[&#039;packagingroot&#039;])) {
            $installedas_dest_dir  = dirname($final_dest_file);
            $installedas_dest_file = $dest_dir . DIRECTORY_SEPARATOR . &#039;.tmp&#039; . basename($final_dest_file);
            $final_dest_file = $this-&gt;_prependPath($final_dest_file, $this-&gt;_options[&#039;packagingroot&#039;]);
        } else {
            $installedas_dest_dir  = dirname($final_dest_file);
            $installedas_dest_file = $installedas_dest_dir . DIRECTORY_SEPARATOR . &#039;.tmp&#039; . basename($final_dest_file);
        }

        $dest_dir  = dirname($final_dest_file);
        $dest_file = $dest_dir . DIRECTORY_SEPARATOR . &#039;.tmp&#039; . basename($final_dest_file);
        if (preg_match(&#039;~/\.\.(/|\\z)|^\.\./~&#039;, str_replace(&#039;\\&#039;, &#039;/&#039;, $dest_file))) {
            return $this-&gt;raiseError(&quot;SECURITY ERROR: file $file (installed to $dest_file) contains parent directory reference ..&quot;, PEAR_INSTALLER_FAILED);
        }
        // }}}

        if (empty($this-&gt;_options[&#039;register-only&#039;]) &amp;&amp;
              (!file_exists($dest_dir) || !is_dir($dest_dir))) {
            if (!$this-&gt;mkDirHier($dest_dir)) {
                return $this-&gt;raiseError(&quot;failed to mkdir $dest_dir&quot;,
                                         PEAR_INSTALLER_FAILED);
            }
            $this-&gt;log(3, &quot;+ mkdir $dest_dir&quot;);
        }

        // pretty much nothing happens if we are only registering the install
        if (empty($this-&gt;_options[&#039;register-only&#039;])) {
            if (empty($atts[&#039;replacements&#039;])) {
                if (!file_exists($orig_file)) {
                    return $this-&gt;raiseError(&quot;file $orig_file does not exist&quot;,
                                             PEAR_INSTALLER_FAILED);
                }

                if (!@copy($orig_file, $dest_file)) {
                    return $this-&gt;raiseError(
                        &quot;failed to write $dest_file: &quot; . error_get_last()[&quot;message&quot;],
                        PEAR_INSTALLER_FAILED);
                }

                $this-&gt;log(3, &quot;+ cp $orig_file $dest_file&quot;);
                if (isset($atts[&#039;md5sum&#039;])) {
                    $md5sum = md5_file($dest_file);
                }
            } else {
                // {{{ file with replacements
                if (!file_exists($orig_file)) {
                    return $this-&gt;raiseError(&quot;file does not exist&quot;,
                                             PEAR_INSTALLER_FAILED);
                }

                $contents = file_get_contents($orig_file);
                if ($contents === false) {
                    $contents = &#039;&#039;;
                }

                if (isset($atts[&#039;md5sum&#039;])) {
                    $md5sum = md5($contents);
                }

                $subst_from = $subst_to = array();
                foreach ($atts[&#039;replacements&#039;] as $a) {
                    $to = &#039;&#039;;
                    if ($a[&#039;type&#039;] == &#039;php-const&#039;) {
                        if (preg_match(&#039;/^[a-z0-9_]+\\z/i&#039;, $a[&#039;to&#039;])) {
                            eval(&quot;\$to = $a[to];&quot;);
                        } else {
                            if (!isset($options[&#039;soft&#039;])) {
                                $this-&gt;log(0, &quot;invalid php-const replacement: $a[to]&quot;);
                            }
                            continue;
                        }
                    } elseif ($a[&#039;type&#039;] == &#039;pear-config&#039;) {
                        if ($a[&#039;to&#039;] == &#039;master_server&#039;) {
                            $chan = $this-&gt;_registry-&gt;getChannel($channel);
                            if (!PEAR::isError($chan)) {
                                $to = $chan-&gt;getServer();
                            } else {
                                $to = $this-&gt;config-&gt;get($a[&#039;to&#039;], null, $channel);
                            }
                        } else {
                            $to = $this-&gt;config-&gt;get($a[&#039;to&#039;], null, $channel);
                        }
                        if (is_null($to)) {
                            if (!isset($options[&#039;soft&#039;])) {
                                $this-&gt;log(0, &quot;invalid pear-config replacement: $a[to]&quot;);
                            }
                            continue;
                        }
                    } elseif ($a[&#039;type&#039;] == &#039;package-info&#039;) {
                        if ($t = $this-&gt;pkginfo-&gt;packageInfo($a[&#039;to&#039;])) {
                            $to = $t;
                        } else {
                            if (!isset($options[&#039;soft&#039;])) {
                                $this-&gt;log(0, &quot;invalid package-info replacement: $a[to]&quot;);
                            }
                            continue;
                        }
                    }
                    if (!is_null($to)) {
                        $subst_from[] = $a[&#039;from&#039;];
                        $subst_to[] = $to;
                    }
                }

                $this-&gt;log(3, &quot;doing &quot;.sizeof($subst_from).&quot; substitution(s) for $final_dest_file&quot;);
                if (sizeof($subst_from)) {
                    $contents = str_replace($subst_from, $subst_to, $contents);
                }

                $wp = @fopen($dest_file, &quot;wb&quot;);
                if (!is_resource($wp)) {
                    return $this-&gt;raiseError(
                        &quot;failed to create $dest_file: &quot; . error_get_last()[&quot;message&quot;],
                        PEAR_INSTALLER_FAILED);
                }

                if (@fwrite($wp, $contents) === false) {
                    return $this-&gt;raiseError(
                        &quot;failed writing to $dest_file: &quot; . error_get_last()[&quot;message&quot;],
                        PEAR_INSTALLER_FAILED);
                }

                fclose($wp);
                // }}}
            }

            // {{{ check the md5
            if (isset($md5sum)) {
                if (strtolower($md5sum) === strtolower($atts[&#039;md5sum&#039;])) {
                    $this-&gt;log(2, &quot;md5sum ok: $final_dest_file&quot;);
                } else {
                    if (empty($options[&#039;force&#039;])) {
                        // delete the file
                        if (file_exists($dest_file)) {
                            unlink($dest_file);
                        }

                        if (!isset($options[&#039;ignore-errors&#039;])) {
                            return $this-&gt;raiseError(&quot;bad md5sum for file $final_dest_file&quot;,
                                                 PEAR_INSTALLER_FAILED);
                        }

                        if (!isset($options[&#039;soft&#039;])) {
                            $this-&gt;log(0, &quot;warning : bad md5sum for file $final_dest_file&quot;);
                        }
                    } else {
                        if (!isset($options[&#039;soft&#039;])) {
                            $this-&gt;log(0, &quot;warning : bad md5sum for file $final_dest_file&quot;);
                        }
                    }
                }
            }
            // }}}
            // {{{ set file permissions
            if (!OS_WINDOWS) {
                if ($atts[&#039;role&#039;] == &#039;script&#039;) {
                    $mode = 0777 &amp; ~(int)octdec($this-&gt;config-&gt;get(&#039;umask&#039;));
                    $this-&gt;log(3, &quot;+ chmod +x $dest_file&quot;);
                } else {
                    $mode = 0666 &amp; ~(int)octdec($this-&gt;config-&gt;get(&#039;umask&#039;));
                }

                if ($atts[&#039;role&#039;] != &#039;src&#039;) {
                    $this-&gt;addFileOperation(&quot;chmod&quot;, array($mode, $dest_file));
                    if (!@chmod($dest_file, $mode)) {
                        if (!isset($options[&#039;soft&#039;])) {
                            $this-&gt;log(0, &quot;failed to change mode of $dest_file: &quot; .
                                          error_get_last()[&quot;message&quot;]);
                        }
                    }
                }
            }
            // }}}

            if ($atts[&#039;role&#039;] == &#039;src&#039;) {
                rename($dest_file, $final_dest_file);
                $this-&gt;log(2, &quot;renamed source file $dest_file to $final_dest_file&quot;);
            } else {
                $this-&gt;addFileOperation(&quot;rename&quot;, array($dest_file, $final_dest_file,
                    $atts[&#039;role&#039;] == &#039;ext&#039;));
            }
        }

        // Store the full path where the file was installed for easy unistall
        if ($atts[&#039;role&#039;] != &#039;script&#039;) {
            $loc = $this-&gt;config-&gt;get($atts[&#039;role&#039;] . &#039;_dir&#039;);
        } else {
            $loc = $this-&gt;config-&gt;get(&#039;bin_dir&#039;);
        }

        if ($atts[&#039;role&#039;] != &#039;src&#039;) {
            $this-&gt;addFileOperation(&quot;installed_as&quot;, array($file, $installed_as,
                                    $loc,
                                    dirname(substr($installedas_dest_file, strlen($loc)))));
        }

        //$this-&gt;log(2, &quot;installed: $dest_file&quot;);
        return PEAR_INSTALLER_OK;
    }

    // }}}
    // {{{ _installFile2()

    /**
     * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
     * @param string filename
     * @param array attributes from &lt;file&gt; tag in package.xml
     * @param string path to install the file in
     * @param array options from command-line
     * @access private
     */
    function _installFile2(&amp;$pkg, $file, &amp;$real_atts, $tmp_path, $options)
    {
        $atts = $real_atts;
        if (!isset($this-&gt;_registry)) {
            $this-&gt;_registry = &amp;$this-&gt;config-&gt;getRegistry();
        }

        $channel = $pkg-&gt;getChannel();
        // {{{ assemble the destination paths
        if (!in_array($atts[&#039;attribs&#039;][&#039;role&#039;],
              PEAR_Installer_Role::getValidRoles($pkg-&gt;getPackageType()))) {
            return $this-&gt;raiseError(&#039;Invalid role `&#039; . $atts[&#039;attribs&#039;][&#039;role&#039;] .
                    &quot;&#039; for file $file&quot;);
        }

        $role = &amp;PEAR_Installer_Role::factory($pkg, $atts[&#039;attribs&#039;][&#039;role&#039;], $this-&gt;config);
        $err  = $role-&gt;setup($this, $pkg, $atts[&#039;attribs&#039;], $file);
        if (PEAR::isError($err)) {
            return $err;
        }

        if (!$role-&gt;isInstallable()) {
            return;
        }

        $info = $role-&gt;processInstallation($pkg, $atts[&#039;attribs&#039;], $file, $tmp_path);
        if (PEAR::isError($info)) {
            return $info;
        }

        list($save_destdir, $dest_dir, $dest_file, $orig_file) = $info;
        if (preg_match(&#039;~/\.\.(/|\\z)|^\.\./~&#039;, str_replace(&#039;\\&#039;, &#039;/&#039;, $dest_file))) {
            return $this-&gt;raiseError(&quot;SECURITY ERROR: file $file (installed to $dest_file) contains parent directory reference ..&quot;, PEAR_INSTALLER_FAILED);
        }

        $final_dest_file = $installed_as = $dest_file;
        if (isset($this-&gt;_options[&#039;packagingroot&#039;])) {
            $final_dest_file = $this-&gt;_prependPath($final_dest_file,
                $this-&gt;_options[&#039;packagingroot&#039;]);
        }

        $dest_dir  = dirname($final_dest_file);
        $dest_file = $dest_dir . DIRECTORY_SEPARATOR . &#039;.tmp&#039; . basename($final_dest_file);
        // }}}

        if (empty($this-&gt;_options[&#039;register-only&#039;])) {
            if (!file_exists($dest_dir) || !is_dir($dest_dir)) {
                if (!$this-&gt;mkDirHier($dest_dir)) {
                    return $this-&gt;raiseError(&quot;failed to mkdir $dest_dir&quot;,
                                             PEAR_INSTALLER_FAILED);
                }
                $this-&gt;log(3, &quot;+ mkdir $dest_dir&quot;);
            }
        }

        $attribs = $atts[&#039;attribs&#039;];
        unset($atts[&#039;attribs&#039;]);
        // pretty much nothing happens if we are only registering the install
        if (empty($this-&gt;_options[&#039;register-only&#039;])) {
            if (!count($atts)) { // no tasks
                if (!file_exists($orig_file)) {
                    return $this-&gt;raiseError(&quot;file $orig_file does not exist&quot;,
                                             PEAR_INSTALLER_FAILED);
                }

                if (!@copy($orig_file, $dest_file)) {
                    return $this-&gt;raiseError(
                        &quot;failed to write $dest_file: &quot; . error_get_last()[&quot;message&quot;],
                        PEAR_INSTALLER_FAILED);
                }

                $this-&gt;log(3, &quot;+ cp $orig_file $dest_file&quot;);
                if (isset($attribs[&#039;md5sum&#039;])) {
                    $md5sum = md5_file($dest_file);
                }
            } else { // file with tasks
                if (!file_exists($orig_file)) {
                    return $this-&gt;raiseError(&quot;file $orig_file does not exist&quot;,
                                             PEAR_INSTALLER_FAILED);
                }

                $contents = file_get_contents($orig_file);
                if ($contents === false) {
                    $contents = &#039;&#039;;
                }

                if (isset($attribs[&#039;md5sum&#039;])) {
                    $md5sum = md5($contents);
                }

                foreach ($atts as $tag =&gt; $raw) {
                    $tag = str_replace(array($pkg-&gt;getTasksNs() . &#039;:&#039;, &#039;-&#039;), array(&#039;&#039;, &#039;_&#039;), $tag);
                    $task = &quot;PEAR_Task_$tag&quot;;
                    $task = new $task($this-&gt;config, $this, PEAR_TASK_INSTALL);
                    if (!$task-&gt;isScript()) { // scripts are only handled after installation
                        $task-&gt;init($raw, $attribs, $pkg-&gt;getLastInstalledVersion());
                        $res = $task-&gt;startSession($pkg, $contents, $final_dest_file);
                        if ($res === false) {
                            continue; // skip this file
                        }

                        if (PEAR::isError($res)) {
                            return $res;
                        }

                        $contents = $res; // save changes
                    }

                    $wp = @fopen($dest_file, &quot;wb&quot;);
                    if (!is_resource($wp)) {
                        return $this-&gt;raiseError(
                            &quot;failed to create $dest_file: &quot; . error_get_last()[&quot;message&quot;],
                            PEAR_INSTALLER_FAILED);
                    }

                    if (fwrite($wp, $contents) === false) {
                        return $this-&gt;raiseError(
                            &quot;failed writing to $dest_file: &quot; . error_get_last()[&quot;message&quot;],
                            PEAR_INSTALLER_FAILED);
                    }

                    fclose($wp);
                }
            }

            // {{{ check the md5
            if (isset($md5sum)) {
                // Make sure the original md5 sum matches with expected
                if (strtolower($md5sum) === strtolower($attribs[&#039;md5sum&#039;])) {
                    $this-&gt;log(2, &quot;md5sum ok: $final_dest_file&quot;);

                    if (isset($contents)) {
                        // set md5 sum based on $content in case any tasks were run.
                        $real_atts[&#039;attribs&#039;][&#039;md5sum&#039;] = md5($contents);
                    }
                } else {
                    if (empty($options[&#039;force&#039;])) {
                        // delete the file
                        if (file_exists($dest_file)) {
                            unlink($dest_file);
                        }

                        if (!isset($options[&#039;ignore-errors&#039;])) {
                            return $this-&gt;raiseError(&quot;bad md5sum for file $final_dest_file&quot;,
                                                     PEAR_INSTALLER_FAILED);
                        }

                        if (!isset($options[&#039;soft&#039;])) {
                            $this-&gt;log(0, &quot;warning : bad md5sum for file $final_dest_file&quot;);
                        }
                    } else {
                        if (!isset($options[&#039;soft&#039;])) {
                            $this-&gt;log(0, &quot;warning : bad md5sum for file $final_dest_file&quot;);
                        }
                    }
                }
            } else {
                $real_atts[&#039;attribs&#039;][&#039;md5sum&#039;] = md5_file($dest_file);
            }

            // }}}
            // {{{ set file permissions
            if (!OS_WINDOWS) {
                if ($role-&gt;isExecutable()) {
                    $mode = 0777 &amp; ~(int)octdec($this-&gt;config-&gt;get(&#039;umask&#039;));
                    $this-&gt;log(3, &quot;+ chmod +x $dest_file&quot;);
                } else {
                    $mode = 0666 &amp; ~(int)octdec($this-&gt;config-&gt;get(&#039;umask&#039;));
                }

                if ($attribs[&#039;role&#039;] != &#039;src&#039;) {
                    $this-&gt;addFileOperation(&quot;chmod&quot;, array($mode, $dest_file));
                    if (!@chmod($dest_file, $mode)) {
                        if (!isset($options[&#039;soft&#039;])) {
                            $this-&gt;log(0, &quot;failed to change mode of $dest_file: &quot; .
                                          error_get_last()[&quot;message&quot;]);
                        }
                    }
                }
            }
            // }}}

            if ($attribs[&#039;role&#039;] == &#039;src&#039;) {
                rename($dest_file, $final_dest_file);
                $this-&gt;log(2, &quot;renamed source file $dest_file to $final_dest_file&quot;);
            } else {
                $this-&gt;addFileOperation(&quot;rename&quot;, array($dest_file, $final_dest_file, $role-&gt;isExtension()));
            }
        }

        // Store the full path where the file was installed for easy uninstall
        if ($attribs[&#039;role&#039;] != &#039;src&#039;) {
            $loc = $this-&gt;config-&gt;get($role-&gt;getLocationConfig(), null, $channel);
            $this-&gt;addFileOperation(&#039;installed_as&#039;, array($file, $installed_as,
                                $loc,
                                dirname(substr($installed_as, strlen($loc)))));
        }

        //$this-&gt;log(2, &quot;installed: $dest_file&quot;);
        return PEAR_INSTALLER_OK;
    }

    // }}}
    // {{{ addFileOperation()

    /**
     * Add a file operation to the current file transaction.
     *
     * @see startFileTransaction()
     * @param string $type This can be one of:
     *    - rename:  rename a file ($data has 3 values)
     *    - backup:  backup an existing file ($data has 1 value)
     *    - removebackup:  clean up backups created during install ($data has 1 value)
     *    - chmod:   change permissions on a file ($data has 2 values)
     *    - delete:  delete a file ($data has 1 value)
     *    - rmdir:   delete a directory if empty ($data has 1 value)
     *    - installed_as: mark a file as installed ($data has 4 values).
     * @param array $data For all file operations, this array must contain the
     *    full path to the file or directory that is being operated on.  For
     *    the rename command, the first parameter must be the file to rename,
     *    the second its new name, the third whether this is a PHP extension.
     *
     *    The installed_as operation contains 4 elements in this order:
     *    1. Filename as listed in the filelist element from package.xml
     *    2. Full path to the installed file
     *    3. Full path from the php_dir configuration variable used in this
     *       installation
     *    4. Relative path from the php_dir that this file is installed in
     */
    function addFileOperation($type, $data)
    {
        if (!is_array($data)) {
            return $this-&gt;raiseError(&#039;Internal Error: $data in addFileOperation&#039;
                . &#039; must be an array, was &#039; . gettype($data));
        }

        if ($type == &#039;chmod&#039;) {
            $octmode = decoct($data[0]);
            $this-&gt;log(3, &quot;adding to transaction: $type $octmode $data[1]&quot;);
        } else {
            $this-&gt;log(3, &quot;adding to transaction: $type &quot; . implode(&quot; &quot;, $data));
        }
        $this-&gt;file_operations[] = array($type, $data);
    }

    // }}}
    // {{{ startFileTransaction()

    function startFileTransaction($rollback_in_case = false)
    {
        if (count($this-&gt;file_operations) &amp;&amp; $rollback_in_case) {
            $this-&gt;rollbackFileTransaction();
        }
        $this-&gt;file_operations = array();
    }

    // }}}
    // {{{ commitFileTransaction()

    function commitFileTransaction()
    {
        // {{{ first, check permissions and such manually
        $errors = array();
        foreach ($this-&gt;file_operations as $key =&gt; $tr) {
            list($type, $data) = $tr;
            switch ($type) {
                case &#039;rename&#039;:
                    if (!file_exists($data[0])) {
                        $errors[] = &quot;cannot rename file $data[0], doesn&#039;t exist&quot;;
                    }

                    // check that dest dir. is writable
                    if (!is_writable(dirname($data[1]))) {
                        $errors[] = &quot;permission denied ($type): $data[1]&quot;;
                    }
                    break;
                case &#039;chmod&#039;:
                    // check that file is writable
                    if (!is_writable($data[1])) {
                        $errors[] = &quot;permission denied ($type): $data[1] &quot; . decoct($data[0]);
                    }
                    break;
                case &#039;delete&#039;:
                    if (!file_exists($data[0])) {
                        $this-&gt;log(2, &quot;warning: file $data[0] doesn&#039;t exist, can&#039;t be deleted&quot;);
                    }
                    // check that directory is writable
                    if (file_exists($data[0])) {
                        if (!is_writable(dirname($data[0]))) {
                            $errors[] = &quot;permission denied ($type): $data[0]&quot;;
                        } else {
                            // make sure the file to be deleted can be opened for writing
                            $fp = false;
                            if (!is_dir($data[0]) &amp;&amp;
                                  (!is_writable($data[0]) || !($fp = @fopen($data[0], &#039;a&#039;)))) {
                                $errors[] = &quot;permission denied ($type): $data[0]&quot;;
                            } elseif ($fp) {
                                fclose($fp);
                            }
                        }

                        /* Verify we are not deleting a file owned by another package
                         * This can happen when a file moves from package A to B in
                         * an upgrade ala http://pear.php.net/17986
                         */
                        $info = array(
                            &#039;package&#039; =&gt; strtolower($this-&gt;pkginfo-&gt;getName()),
                            &#039;channel&#039; =&gt; strtolower($this-&gt;pkginfo-&gt;getChannel()),
                        );
                        $result = $this-&gt;_registry-&gt;checkFileMap($data[0], $info, &#039;1.1&#039;);
                        if (is_array($result)) {
                            $res = array_diff($result, $info);
                            if (!empty($res)) {
                                $new = $this-&gt;_registry-&gt;getPackage($result[1], $result[0]);
                                $this-&gt;file_operations[$key] = false;
                                $pkginfoName = $this-&gt;pkginfo-&gt;getName();
                                $newChannel  = $new-&gt;getChannel();
                                $newPackage  = $new-&gt;getName();
                                $this-&gt;log(3, &quot;file $data[0] was scheduled for removal from $pkginfoName but is owned by $newChannel/$newPackage, removal has been cancelled.&quot;);
                            }
                        }
                    }
                    break;
            }

        }
        // }}}

        $n = count($this-&gt;file_operations);
        $this-&gt;log(2, &quot;about to commit $n file operations for &quot; . $this-&gt;pkginfo-&gt;getName());

        $m = count($errors);
        if ($m &gt; 0) {
            foreach ($errors as $error) {
                if (!isset($this-&gt;_options[&#039;soft&#039;])) {
                    $this-&gt;log(1, $error);
                }
            }

            if (!isset($this-&gt;_options[&#039;ignore-errors&#039;])) {
                return false;
            }
        }

        $this-&gt;_dirtree = array();
        // {{{ really commit the transaction
        foreach ($this-&gt;file_operations as $i =&gt; $tr) {
            if (!$tr) {
                // support removal of non-existing backups
                continue;
            }

            list($type, $data) = $tr;
            switch ($type) {
                case &#039;backup&#039;:
                    if (!file_exists($data[0])) {
                        $this-&gt;file_operations[$i] = false;
                        break;
                    }

                    if (!@copy($data[0], $data[0] . &#039;.bak&#039;)) {
                        $this-&gt;log(1, &#039;Could not copy &#039; . $data[0] . &#039; to &#039; . $data[0] .
                            &#039;.bak &#039; . error_get_last()[&quot;message&quot;]);
                        return false;
                    }
                    $this-&gt;log(3, &quot;+ backup $data[0] to $data[0].bak&quot;);
                    break;
                case &#039;removebackup&#039;:
                    if (file_exists($data[0] . &#039;.bak&#039;) &amp;&amp; is_writable($data[0] . &#039;.bak&#039;)) {
                        unlink($data[0] . &#039;.bak&#039;);
                        $this-&gt;log(3, &quot;+ rm backup of $data[0] ($data[0].bak)&quot;);
                    }
                    break;
                case &#039;rename&#039;:
                    $test = file_exists($data[1]) ? @unlink($data[1]) : null;
                    if (!$test &amp;&amp; file_exists($data[1])) {
                        if ($data[2]) {
                            $extra = &#039;, this extension must be installed manually.  Rename to &quot;&#039; .
                                basename($data[1]) . &#039;&quot;&#039;;
                        } else {
                            $extra = &#039;&#039;;
                        }

                        if (!isset($this-&gt;_options[&#039;soft&#039;])) {
                            $this-&gt;log(1, &#039;Could not delete &#039; . $data[1] . &#039;, cannot rename &#039; .
                                $data[0] . $extra);
                        }

                        if (!isset($this-&gt;_options[&#039;ignore-errors&#039;])) {
                            return false;
                        }
                    }

                    // permissions issues with rename - copy() is far superior
                    $perms = @fileperms($data[0]);
                    if (!@copy($data[0], $data[1])) {
                        $this-&gt;log(1, &#039;Could not rename &#039; . $data[0] . &#039; to &#039; . $data[1] .
                            &#039; &#039; . error_get_last()[&quot;message&quot;]);
                        return false;
                    }

                    // copy over permissions, otherwise they are lost
                    @chmod($data[1], $perms);
                    @unlink($data[0]);
                    $this-&gt;log(3, &quot;+ mv $data[0] $data[1]&quot;);
                    break;
                case &#039;chmod&#039;:
                    if (!@chmod($data[1], $data[0])) {
                        $this-&gt;log(1, &#039;Could not chmod &#039; . $data[1] . &#039; to &#039; .
                            decoct($data[0]) . &#039; &#039; . error_get_last()[&quot;message&quot;]);
                        return false;
                    }

                    $octmode = decoct($data[0]);
                    $this-&gt;log(3, &quot;+ chmod $octmode $data[1]&quot;);
                    break;
                case &#039;delete&#039;:
                    if (file_exists($data[0])) {
                        if (!@unlink($data[0])) {
                            $this-&gt;log(1, &#039;Could not delete &#039; . $data[0] . &#039; &#039; .
                                error_get_last()[&quot;message&quot;]);
                            return false;
                        }
                        $this-&gt;log(3, &quot;+ rm $data[0]&quot;);
                    }
                    break;
                case &#039;rmdir&#039;:
                    if (file_exists($data[0])) {
                        do {
                            $testme = opendir($data[0]);
                            while (false !== ($entry = readdir($testme))) {
                                if ($entry == &#039;.&#039; || $entry == &#039;..&#039;) {
                                    continue;
                                }
                                closedir($testme);
                                break 2; // this directory is not empty and can&#039;t be
                                         // deleted
                            }

                            closedir($testme);
                            if (!@rmdir($data[0])) {
                                $this-&gt;log(1, &#039;Could not rmdir &#039; . $data[0] . &#039; &#039; .
                                    error_get_last()[&quot;message&quot;]);
                                return false;
                            }
                            $this-&gt;log(3, &quot;+ rmdir $data[0]&quot;);
                        } while (false);
                    }
                    break;
                case &#039;installed_as&#039;:
                    $this-&gt;pkginfo-&gt;setInstalledAs($data[0], $data[1]);
                    if (!isset($this-&gt;_dirtree[dirname($data[1])])) {
                        $this-&gt;_dirtree[dirname($data[1])] = true;
                        $this-&gt;pkginfo-&gt;setDirtree(dirname($data[1]));

                        while(!empty($data[3]) &amp;&amp; dirname($data[3]) != $data[3] &amp;&amp;
                                $data[3] != &#039;/&#039; &amp;&amp; $data[3] != &#039;\\&#039;) {
                            $this-&gt;pkginfo-&gt;setDirtree($pp =
                                $this-&gt;_prependPath($data[3], $data[2]));
                            $this-&gt;_dirtree[$pp] = true;
                            $data[3] = dirname($data[3]);
                        }
                    }
                    break;
            }
        }
        // }}}
        $this-&gt;log(2, &quot;successfully committed $n file operations&quot;);
        $this-&gt;file_operations = array();
        return true;
    }

    // }}}
    // {{{ rollbackFileTransaction()

    function rollbackFileTransaction()
    {
        $n = count($this-&gt;file_operations);
        $this-&gt;log(2, &quot;rolling back $n file operations&quot;);
        foreach ($this-&gt;file_operations as $tr) {
            list($type, $data) = $tr;
            switch ($type) {
                case &#039;backup&#039;:
                    if (file_exists($data[0] . &#039;.bak&#039;)) {
                        if (file_exists($data[0] &amp;&amp; is_writable($data[0]))) {
                            unlink($data[0]);
                        }
                        @copy($data[0] . &#039;.bak&#039;, $data[0]);
                        $this-&gt;log(3, &quot;+ restore $data[0] from $data[0].bak&quot;);
                    }
                    break;
                case &#039;removebackup&#039;:
                    if (file_exists($data[0] . &#039;.bak&#039;) &amp;&amp; is_writable($data[0] . &#039;.bak&#039;)) {
                        unlink($data[0] . &#039;.bak&#039;);
                        $this-&gt;log(3, &quot;+ rm backup of $data[0] ($data[0].bak)&quot;);
                    }
                    break;
                case &#039;rename&#039;:
                    @unlink($data[0]);
                    $this-&gt;log(3, &quot;+ rm $data[0]&quot;);
                    break;
                case &#039;mkdir&#039;:
                    @rmdir($data[0]);
                    $this-&gt;log(3, &quot;+ rmdir $data[0]&quot;);
                    break;
                case &#039;chmod&#039;:
                    break;
                case &#039;delete&#039;:
                    break;
                case &#039;installed_as&#039;:
                    $this-&gt;pkginfo-&gt;setInstalledAs($data[0], false);
                    break;
            }
        }
        $this-&gt;pkginfo-&gt;resetDirtree();
        $this-&gt;file_operations = array();
    }

    // }}}
    // {{{ mkDirHier($dir)

    function mkDirHier($dir)
    {
        $this-&gt;addFileOperation(&#039;mkdir&#039;, array($dir));
        return parent::mkDirHier($dir);
    }

    // }}}
    // {{{ _parsePackageXml()

    function _parsePackageXml(&amp;$descfile)
    {
        // Parse xml file -----------------------------------------------
        $pkg = new PEAR_PackageFile($this-&gt;config, $this-&gt;debug);
        PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
        $p = &amp;$pkg-&gt;fromAnyFile($descfile, PEAR_VALIDATE_INSTALLING);
        PEAR::staticPopErrorHandling();
        if (PEAR::isError($p)) {
            if (is_array($p-&gt;getUserInfo())) {
                foreach ($p-&gt;getUserInfo() as $err) {
                    $loglevel = $err[&#039;level&#039;] == &#039;error&#039; ? 0 : 1;
                    if (!isset($this-&gt;_options[&#039;soft&#039;])) {
                        $this-&gt;log($loglevel, ucfirst($err[&#039;level&#039;]) . &#039;: &#039; . $err[&#039;message&#039;]);
                    }
                }
            }
            return $this-&gt;raiseError(&#039;Installation failed: invalid package file&#039;);
        }

        $descfile = $p-&gt;getPackageFile();
        return $p;
    }

    // }}}
    /**
     * Set the list of PEAR_Downloader_Package objects to allow more sane
     * dependency validation
     * @param array
     */
    function setDownloadedPackages(&amp;$pkgs)
    {
        PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
        $err = $this-&gt;analyzeDependencies($pkgs);
        PEAR::popErrorHandling();
        if (PEAR::isError($err)) {
            return $err;
        }
        $this-&gt;_downloadedPackages = &amp;$pkgs;
    }

    /**
     * Set the list of PEAR_Downloader_Package objects to allow more sane
     * dependency validation
     * @param array
     */
    function setUninstallPackages(&amp;$pkgs)
    {
        $this-&gt;_downloadedPackages = &amp;$pkgs;
    }

    function getInstallPackages()
    {
        return $this-&gt;_downloadedPackages;
    }

    // {{{ install()

    /**
     * Installs the files within the package file specified.
     *
     * @param string|PEAR_Downloader_Package $pkgfile path to the package file,
     *        or a pre-initialized packagefile object
     * @param array $options
     * recognized options:
     * - installroot   : optional prefix directory for installation
     * - force         : force installation
     * - register-only : update registry but don&#039;t install files
     * - upgrade       : upgrade existing install
     * - soft          : fail silently
     * - nodeps        : ignore dependency conflicts/missing dependencies
     * - alldeps       : install all dependencies
     * - onlyreqdeps   : install only required dependencies
     *
     * @return array|PEAR_Error package info if successful
     */
    function install($pkgfile, $options = array())
    {
        $this-&gt;_options = $options;
        $this-&gt;_registry = &amp;$this-&gt;config-&gt;getRegistry();
        if (is_object($pkgfile)) {
            $dlpkg    = &amp;$pkgfile;
            $pkg      = $pkgfile-&gt;getPackageFile();
            $pkgfile  = $pkg-&gt;getArchiveFile();
            $descfile = $pkg-&gt;getPackageFile();
        } else {
            $descfile = $pkgfile;
            $pkg      = $this-&gt;_parsePackageXml($descfile);
            if (PEAR::isError($pkg)) {
                return $pkg;
            }
        }

        $tmpdir = dirname($descfile);
        if (realpath($descfile) != realpath($pkgfile)) {
            // Use the temp_dir since $descfile can contain the download dir path
            $tmpdir = $this-&gt;config-&gt;get(&#039;temp_dir&#039;, null, &#039;pear.php.net&#039;);
            $tmpdir = System::mktemp(&#039;-d -t &quot;&#039; . $tmpdir . &#039;&quot;&#039;);

            $tar = new Archive_Tar($pkgfile);
            if (!$tar-&gt;extract($tmpdir)) {
                return $this-&gt;raiseError(&quot;unable to unpack $pkgfile&quot;);
            }
        }

        $pkgname = $pkg-&gt;getName();
        $channel = $pkg-&gt;getChannel();

        if (isset($options[&#039;installroot&#039;])) {
            $this-&gt;config-&gt;setInstallRoot($options[&#039;installroot&#039;]);
            $this-&gt;_registry = &amp;$this-&gt;config-&gt;getRegistry();
            $installregistry = &amp;$this-&gt;_registry;
            $this-&gt;installroot = &#039;&#039;; // all done automagically now
            $php_dir = $this-&gt;config-&gt;get(&#039;php_dir&#039;, null, $channel);
        } else {
            $this-&gt;config-&gt;setInstallRoot(false);
            $this-&gt;_registry = &amp;$this-&gt;config-&gt;getRegistry();
            if (isset($this-&gt;_options[&#039;packagingroot&#039;])) {
                $regdir = $this-&gt;_prependPath(
                    $this-&gt;config-&gt;get(&#039;php_dir&#039;, null, &#039;pear.php.net&#039;),
                    $this-&gt;_options[&#039;packagingroot&#039;]);

                $metadata_dir = $this-&gt;config-&gt;get(&#039;metadata_dir&#039;, null, &#039;pear.php.net&#039;);
                if ($metadata_dir) {
                    $metadata_dir = $this-&gt;_prependPath(
                        $metadata_dir,
                        $this-&gt;_options[&#039;packagingroot&#039;]);
                }
                $packrootphp_dir = $this-&gt;_prependPath(
                    $this-&gt;config-&gt;get(&#039;php_dir&#039;, null, $channel),
                    $this-&gt;_options[&#039;packagingroot&#039;]);

                $installregistry = new PEAR_Registry($regdir, false, false, $metadata_dir);
                if (!$installregistry-&gt;channelExists($channel, true)) {
                    // we need to fake a channel-discover of this channel
                    $chanobj = $this-&gt;_registry-&gt;getChannel($channel, true);
                    $installregistry-&gt;addChannel($chanobj);
                }
                $php_dir = $packrootphp_dir;
            } else {
                $installregistry = &amp;$this-&gt;_registry;
                $php_dir = $this-&gt;config-&gt;get(&#039;php_dir&#039;, null, $channel);
            }
            $this-&gt;installroot = &#039;&#039;;
        }

        // {{{ checks to do when not in &quot;force&quot; mode
        if (empty($options[&#039;force&#039;]) &amp;&amp;
              (file_exists($this-&gt;config-&gt;get(&#039;php_dir&#039;)) &amp;&amp;
               is_dir($this-&gt;config-&gt;get(&#039;php_dir&#039;)))) {
            $testp = $channel == &#039;pear.php.net&#039; ? $pkgname : array($channel, $pkgname);
            $instfilelist = $pkg-&gt;getInstallationFileList(true);
            if (PEAR::isError($instfilelist)) {
                return $instfilelist;
            }

            // ensure we have the most accurate registry
            $installregistry-&gt;flushFileMap();
            $test = $installregistry-&gt;checkFileMap($instfilelist, $testp, &#039;1.1&#039;);
            if (PEAR::isError($test)) {
                return $test;
            }

            if (sizeof($test)) {
                $pkgs = $this-&gt;getInstallPackages();
                $found = false;
                foreach ($pkgs as $param) {
                    if ($pkg-&gt;isSubpackageOf($param)) {
                        $found = true;
                        break;
                    }
                }

                if ($found) {
                    // subpackages can conflict with earlier versions of parent packages
                    $parentreg = $installregistry-&gt;packageInfo($param-&gt;getPackage(), null, $param-&gt;getChannel());
                    $tmp = $test;
                    foreach ($tmp as $file =&gt; $info) {
                        if (is_array($info)) {
                            if (strtolower($info[1]) == strtolower($param-&gt;getPackage()) &amp;&amp;
                                  strtolower($info[0]) == strtolower($param-&gt;getChannel())
                            ) {
                                if (isset($parentreg[&#039;filelist&#039;][$file])) {
                                    unset($parentreg[&#039;filelist&#039;][$file]);
                                } else{
                                    $pos     = strpos($file, &#039;/&#039;);
                                    $basedir = substr($file, 0, $pos);
                                    $file2   = substr($file, $pos + 1);
                                    if (isset($parentreg[&#039;filelist&#039;][$file2][&#039;baseinstalldir&#039;])
                                        &amp;&amp; $parentreg[&#039;filelist&#039;][$file2][&#039;baseinstalldir&#039;] === $basedir
                                    ) {
                                        unset($parentreg[&#039;filelist&#039;][$file2]);
                                    }
                                }

                                unset($test[$file]);
                            }
                        } else {
                            if (strtolower($param-&gt;getChannel()) != &#039;pear.php.net&#039;) {
                                continue;
                            }

                            if (strtolower($info) == strtolower($param-&gt;getPackage())) {
                                if (isset($parentreg[&#039;filelist&#039;][$file])) {
                                    unset($parentreg[&#039;filelist&#039;][$file]);
                                } else{
                                    $pos     = strpos($file, &#039;/&#039;);
                                    $basedir = substr($file, 0, $pos);
                                    $file2   = substr($file, $pos + 1);
                                    if (isset($parentreg[&#039;filelist&#039;][$file2][&#039;baseinstalldir&#039;])
                                        &amp;&amp; $parentreg[&#039;filelist&#039;][$file2][&#039;baseinstalldir&#039;] === $basedir
                                    ) {
                                        unset($parentreg[&#039;filelist&#039;][$file2]);
                                    }
                                }

                                unset($test[$file]);
                            }
                        }
                    }

                    $pfk = new PEAR_PackageFile($this-&gt;config);
                    $parentpkg = &amp;$pfk-&gt;fromArray($parentreg);
                    $installregistry-&gt;updatePackage2($parentpkg);
                }

                if ($param-&gt;getChannel() == &#039;pecl.php.net&#039; &amp;&amp; isset($options[&#039;upgrade&#039;])) {
                    $tmp = $test;
                    foreach ($tmp as $file =&gt; $info) {
                        if (is_string($info)) {
                            // pear.php.net packages are always stored as strings
                            if (strtolower($info) == strtolower($param-&gt;getPackage())) {
                                // upgrading existing package
                                unset($test[$file]);
                            }
                        }
                    }
                }

                if (count($test)) {
                    $msg = &quot;$channel/$pkgname: conflicting files found:\n&quot;;
                    $longest = max(array_map(&quot;strlen&quot;, array_keys($test)));
                    $fmt = &quot;%{$longest}s (%s)\n&quot;;
                    foreach ($test as $file =&gt; $info) {
                        if (!is_array($info)) {
                            $info = array(&#039;pear.php.net&#039;, $info);
                        }
                        $info = $info[0] . &#039;/&#039; . $info[1];
                        $msg .= sprintf($fmt, $file, $info);
                    }

                    if (!isset($options[&#039;ignore-errors&#039;])) {
                        return $this-&gt;raiseError($msg);
                    }

                    if (!isset($options[&#039;soft&#039;])) {
                        $this-&gt;log(0, &quot;WARNING: $msg&quot;);
                    }
                }
            }
        }
        // }}}

        $this-&gt;startFileTransaction();

        $usechannel = $channel;
        if ($channel == &#039;pecl.php.net&#039;) {
            $test = $installregistry-&gt;packageExists($pkgname, $channel);
            if (!$test) {
                $test = $installregistry-&gt;packageExists($pkgname, &#039;pear.php.net&#039;);
                $usechannel = &#039;pear.php.net&#039;;
            }
        } else {
            $test = $installregistry-&gt;packageExists($pkgname, $channel);
        }

        if (empty($options[&#039;upgrade&#039;]) &amp;&amp; empty($options[&#039;soft&#039;])) {
            // checks to do only when installing new packages
            if (empty($options[&#039;force&#039;]) &amp;&amp; $test) {
                return $this-&gt;raiseError(&quot;$channel/$pkgname is already installed&quot;);
            }
        } else {
            // Upgrade
            if ($test) {
                $v1 = $installregistry-&gt;packageInfo($pkgname, &#039;version&#039;, $usechannel);
                $v2 = $pkg-&gt;getVersion();
                $cmp = version_compare(&quot;$v1&quot;, &quot;$v2&quot;, &#039;gt&#039;);
                if (empty($options[&#039;force&#039;]) &amp;&amp; !version_compare(&quot;$v2&quot;, &quot;$v1&quot;, &#039;gt&#039;)) {
                    return $this-&gt;raiseError(&quot;upgrade to a newer version ($v2 is not newer than $v1)&quot;);
                }
            }
        }

        // Do cleanups for upgrade and install, remove old release&#039;s files first
        if ($test &amp;&amp; empty($options[&#039;register-only&#039;])) {
            // when upgrading, remove old release&#039;s files first:
            if (PEAR::isError($err = $this-&gt;_deletePackageFiles($pkgname, $usechannel,
                  true))) {
                if (!isset($options[&#039;ignore-errors&#039;])) {
                    return $this-&gt;raiseError($err);
                }

                if (!isset($options[&#039;soft&#039;])) {
                    $this-&gt;log(0, &#039;WARNING: &#039; . $err-&gt;getMessage());
                }
            } else {
                $backedup = $err;
            }
        }

        // {{{ Copy files to dest dir ---------------------------------------

        // info from the package it self we want to access from _installFile
        $this-&gt;pkginfo = &amp;$pkg;
        // used to determine whether we should build any C code
        $this-&gt;source_files = 0;

        $savechannel = $this-&gt;config-&gt;get(&#039;default_channel&#039;);
        if (empty($options[&#039;register-only&#039;]) &amp;&amp; !is_dir($php_dir)) {
            if (PEAR::isError(System::mkdir(array(&#039;-p&#039;), $php_dir))) {
                return $this-&gt;raiseError(&quot;no installation destination directory &#039;$php_dir&#039;\n&quot;);
            }
        }

        if (substr($pkgfile, -4) != &#039;.xml&#039;) {
            $tmpdir .= DIRECTORY_SEPARATOR . $pkgname . &#039;-&#039; . $pkg-&gt;getVersion();
        }

        $this-&gt;configSet(&#039;default_channel&#039;, $channel);
        // {{{ install files

        $ver = $pkg-&gt;getPackagexmlVersion();
        if (version_compare($ver, &#039;2.0&#039;, &#039;&gt;=&#039;)) {
            $filelist = $pkg-&gt;getInstallationFilelist();
        } else {
            $filelist = $pkg-&gt;getFileList();
        }

        if (PEAR::isError($filelist)) {
            return $filelist;
        }

        $p = &amp;$installregistry-&gt;getPackage($pkgname, $channel);
        $dirtree = (empty($options[&#039;register-only&#039;]) &amp;&amp; $p) ? $p-&gt;getDirTree() : false;

        $pkg-&gt;resetFilelist();
        $pkg-&gt;setLastInstalledVersion($installregistry-&gt;packageInfo($pkg-&gt;getPackage(),
            &#039;version&#039;, $pkg-&gt;getChannel()));
        foreach ($filelist as $file =&gt; $atts) {
            $this-&gt;expectError(PEAR_INSTALLER_FAILED);
            if ($pkg-&gt;getPackagexmlVersion() == &#039;1.0&#039;) {
                $res = $this-&gt;_installFile($file, $atts, $tmpdir, $options);
            } else {
                $res = $this-&gt;_installFile2($pkg, $file, $atts, $tmpdir, $options);
            }
            $this-&gt;popExpect();

            if (PEAR::isError($res)) {
                if (empty($options[&#039;ignore-errors&#039;])) {
                    $this-&gt;rollbackFileTransaction();
                    if ($res-&gt;getMessage() == &quot;file does not exist&quot;) {
                        $this-&gt;raiseError(&quot;file $file in package.xml does not exist&quot;);
                    }

                    return $this-&gt;raiseError($res);
                }

                if (!isset($options[&#039;soft&#039;])) {
                    $this-&gt;log(0, &quot;Warning: &quot; . $res-&gt;getMessage());
                }
            }

            $real = isset($atts[&#039;attribs&#039;]) ? $atts[&#039;attribs&#039;] : $atts;
            if ($res == PEAR_INSTALLER_OK &amp;&amp; $real[&#039;role&#039;] != &#039;src&#039;) {
                // Register files that were installed
                $pkg-&gt;installedFile($file, $atts);
            }
        }
        // }}}

        // {{{ compile and install source files
        if ($this-&gt;source_files &gt; 0 &amp;&amp; empty($options[&#039;nobuild&#039;])) {
            $configureoptions = empty($options[&#039;configureoptions&#039;]) ? &#039;&#039; : $options[&#039;configureoptions&#039;];
            if (PEAR::isError($err =
                  $this-&gt;_compileSourceFiles($savechannel, $pkg, $configureoptions))) {
                return $err;
            }
        }
        // }}}

        if (isset($backedup)) {
            $this-&gt;_removeBackups($backedup);
        }

        if (!$this-&gt;commitFileTransaction()) {
            $this-&gt;rollbackFileTransaction();
            $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
            return $this-&gt;raiseError(&quot;commit failed&quot;, PEAR_INSTALLER_FAILED);
        }
        // }}}

        $ret          = false;
        $installphase = &#039;install&#039;;
        $oldversion   = false;
        // {{{ Register that the package is installed -----------------------
        if (empty($options[&#039;upgrade&#039;])) {
            // if &#039;force&#039; is used, replace the info in registry
            $usechannel = $channel;
            if ($channel == &#039;pecl.php.net&#039;) {
                $test = $installregistry-&gt;packageExists($pkgname, $channel);
                if (!$test) {
                    $test = $installregistry-&gt;packageExists($pkgname, &#039;pear.php.net&#039;);
                    $usechannel = &#039;pear.php.net&#039;;
                }
            } else {
                $test = $installregistry-&gt;packageExists($pkgname, $channel);
            }

            if (!empty($options[&#039;force&#039;]) &amp;&amp; $test) {
                $oldversion = $installregistry-&gt;packageInfo($pkgname, &#039;version&#039;, $usechannel);
                $installregistry-&gt;deletePackage($pkgname, $usechannel);
            }
            $ret = $installregistry-&gt;addPackage2($pkg);
        } else {
            if ($dirtree) {
                $this-&gt;startFileTransaction();
                // attempt to delete empty directories
                uksort($dirtree, array($this, &#039;_sortDirs&#039;));
                foreach($dirtree as $dir =&gt; $notused) {
                    $this-&gt;addFileOperation(&#039;rmdir&#039;, array($dir));
                }
                $this-&gt;commitFileTransaction();
            }

            $usechannel = $channel;
            if ($channel == &#039;pecl.php.net&#039;) {
                $test = $installregistry-&gt;packageExists($pkgname, $channel);
                if (!$test) {
                    $test = $installregistry-&gt;packageExists($pkgname, &#039;pear.php.net&#039;);
                    $usechannel = &#039;pear.php.net&#039;;
                }
            } else {
                $test = $installregistry-&gt;packageExists($pkgname, $channel);
            }

            // new: upgrade installs a package if it isn&#039;t installed
            if (!$test) {
                $ret = $installregistry-&gt;addPackage2($pkg);
            } else {
                if ($usechannel != $channel) {
                    $installregistry-&gt;deletePackage($pkgname, $usechannel);
                    $ret = $installregistry-&gt;addPackage2($pkg);
                } else {
                    $ret = $installregistry-&gt;updatePackage2($pkg);
                }
                $installphase = &#039;upgrade&#039;;
            }
        }

        if (!$ret) {
            $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
            return $this-&gt;raiseError(&quot;Adding package $channel/$pkgname to registry failed&quot;);
        }
        // }}}

        $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
        if (class_exists(&#039;PEAR_Task_Common&#039;)) { // this is auto-included if any tasks exist
            if (PEAR_Task_Common::hasPostinstallTasks()) {
                PEAR_Task_Common::runPostinstallTasks($installphase);
            }
        }

        return $pkg-&gt;toArray(true);
    }

    // }}}

    // {{{ _compileSourceFiles()
    /**
     * @param string
     * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
     * @param mixed[] $configureoptions
     */
    function _compileSourceFiles($savechannel, &amp;$filelist, $configureoptions)
    {
        require_once &#039;PEAR/Builder.php&#039;;
        $this-&gt;log(1, &quot;$this-&gt;source_files source files, building&quot;);
        $bob = new PEAR_Builder($configureoptions, $this-&gt;ui);
        $bob-&gt;debug = $this-&gt;debug;
        $built = $bob-&gt;build($filelist, array(&amp;$this, &#039;_buildCallback&#039;));
        if (PEAR::isError($built)) {
            $this-&gt;rollbackFileTransaction();
            $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
            return $built;
        }

        $this-&gt;log(1, &quot;\nBuild process completed successfully&quot;);
        foreach ($built as $ext) {
            $bn = basename($ext[&#039;file&#039;]);
            list($_ext_name, $_ext_suff) = explode(&#039;.&#039;, $bn);
            if ($_ext_suff == &#039;so&#039; || $_ext_suff == &#039;dll&#039;) {
                if (extension_loaded($_ext_name)) {
                    return $this-&gt;raiseError(&quot;Extension &#039;$_ext_name&#039; already loaded. &quot; .
                                             &#039;Please unload it in your php.ini file &#039; .
                                             &#039;prior to install or upgrade&#039;);
                }
                $role = &#039;ext&#039;;
            } else {
                $role = &#039;src&#039;;
            }

            $dest = $ext[&#039;dest&#039;];
            $packagingroot = &#039;&#039;;
            if (isset($this-&gt;_options[&#039;packagingroot&#039;])) {
                $packagingroot = $this-&gt;_options[&#039;packagingroot&#039;];
            }

            $copyto = $this-&gt;_prependPath($dest, $packagingroot);
            $extra  = $copyto != $dest ? &quot; as &#039;$copyto&#039;&quot; : &#039;&#039;;
            $this-&gt;log(1, &quot;Installing &#039;$dest&#039;$extra&quot;);

            $copydir = dirname($copyto);
            // pretty much nothing happens if we are only registering the install
            if (empty($this-&gt;_options[&#039;register-only&#039;])) {
                if (!file_exists($copydir) || !is_dir($copydir)) {
                    if (!$this-&gt;mkDirHier($copydir)) {
                        return $this-&gt;raiseError(&quot;failed to mkdir $copydir&quot;,
                            PEAR_INSTALLER_FAILED);
                    }

                    $this-&gt;log(3, &quot;+ mkdir $copydir&quot;);
                }

                if (!@copy($ext[&#039;file&#039;], $copyto)) {
                    return $this-&gt;raiseError(
                        &quot;failed to write $copyto (&quot; . error_get_last()[&quot;message&quot;] . &quot;)&quot;,
                        PEAR_INSTALLER_FAILED);
                }

                $this-&gt;log(3, &quot;+ cp $ext[file] $copyto&quot;);
                $this-&gt;addFileOperation(&#039;rename&#039;, array($ext[&#039;file&#039;], $copyto));
                if (!OS_WINDOWS) {
                    $mode = 0666 &amp; ~(int)octdec($this-&gt;config-&gt;get(&#039;umask&#039;));
                    $this-&gt;addFileOperation(&#039;chmod&#039;, array($mode, $copyto));
                    if (!@chmod($copyto, $mode)) {
                        $this-&gt;log(0, &quot;failed to change mode of $copyto (&quot; .
                                      error_get_last()[&quot;message&quot;] . &quot;)&quot;);
                    }
                }
            }


            $data = array(
                &#039;role&#039;         =&gt; $role,
                &#039;name&#039;         =&gt; $bn,
                &#039;installed_as&#039; =&gt; $dest,
                &#039;php_api&#039;      =&gt; $ext[&#039;php_api&#039;],
                &#039;zend_mod_api&#039; =&gt; $ext[&#039;zend_mod_api&#039;],
                &#039;zend_ext_api&#039; =&gt; $ext[&#039;zend_ext_api&#039;],
            );

            if ($filelist-&gt;getPackageXmlVersion() == &#039;1.0&#039;) {
                $filelist-&gt;installedFile($bn, $data);
            } else {
                $filelist-&gt;installedFile($bn, array(&#039;attribs&#039; =&gt; $data));
            }
        }
    }

    // }}}
    function &amp;getUninstallPackages()
    {
        return $this-&gt;_downloadedPackages;
    }
    // {{{ uninstall()

    /**
     * Uninstall a package
     *
     * This method removes all files installed by the application, and then
     * removes any empty directories.
     * @param string package name
     * @param array Command-line options.  Possibilities include:
     *
     *              - installroot: base installation dir, if not the default
     *              - register-only : update registry but don&#039;t remove files
     *              - nodeps: do not process dependencies of other packages to ensure
     *                        uninstallation does not break things
     */
    function uninstall($package, $options = array())
    {
        $installRoot = isset($options[&#039;installroot&#039;]) ? $options[&#039;installroot&#039;] : &#039;&#039;;
        $this-&gt;config-&gt;setInstallRoot($installRoot);

        $this-&gt;installroot = &#039;&#039;;
        $this-&gt;_registry = &amp;$this-&gt;config-&gt;getRegistry();
        if (is_object($package)) {
            $channel = $package-&gt;getChannel();
            $pkg     = $package;
            $package = $pkg-&gt;getPackage();
        } else {
            $pkg = false;
            $info = $this-&gt;_registry-&gt;parsePackageName($package,
                $this-&gt;config-&gt;get(&#039;default_channel&#039;));
            $channel = $info[&#039;channel&#039;];
            $package = $info[&#039;package&#039;];
        }

        $savechannel = $this-&gt;config-&gt;get(&#039;default_channel&#039;);
        $this-&gt;configSet(&#039;default_channel&#039;, $channel);
        if (!is_object($pkg)) {
            $pkg = $this-&gt;_registry-&gt;getPackage($package, $channel);
        }

        if (!$pkg) {
            $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
            return $this-&gt;raiseError($this-&gt;_registry-&gt;parsedPackageNameToString(
                array(
                    &#039;channel&#039; =&gt; $channel,
                    &#039;package&#039; =&gt; $package
                ), true) . &#039; not installed&#039;);
        }

        if ($pkg-&gt;getInstalledBinary()) {
            // this is just an alias for a binary package
            return $this-&gt;_registry-&gt;deletePackage($package, $channel);
        }

        $filelist = $pkg-&gt;getFilelist();
        PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
        if (!class_exists(&#039;PEAR_Dependency2&#039;)) {
            require_once &#039;PEAR/Dependency2.php&#039;;
        }

        $depchecker = new PEAR_Dependency2($this-&gt;config, $options,
            array(&#039;channel&#039; =&gt; $channel, &#039;package&#039; =&gt; $package),
            PEAR_VALIDATE_UNINSTALLING);
        $e = $depchecker-&gt;validatePackageUninstall($this);
        PEAR::staticPopErrorHandling();
        if (PEAR::isError($e)) {
            if (!isset($options[&#039;ignore-errors&#039;])) {
                return $this-&gt;raiseError($e);
            }

            if (!isset($options[&#039;soft&#039;])) {
                $this-&gt;log(0, &#039;WARNING: &#039; . $e-&gt;getMessage());
            }
        } elseif (is_array($e)) {
            if (!isset($options[&#039;soft&#039;])) {
                $this-&gt;log(0, $e[0]);
            }
        }

        $this-&gt;pkginfo = &amp;$pkg;
        // pretty much nothing happens if we are only registering the uninstall
        if (empty($options[&#039;register-only&#039;])) {
            // {{{ Delete the files
            $this-&gt;startFileTransaction();
            PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
            if (PEAR::isError($err = $this-&gt;_deletePackageFiles($package, $channel))) {
                PEAR::popErrorHandling();
                $this-&gt;rollbackFileTransaction();
                $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
                if (!isset($options[&#039;ignore-errors&#039;])) {
                    return $this-&gt;raiseError($err);
                }

                if (!isset($options[&#039;soft&#039;])) {
                    $this-&gt;log(0, &#039;WARNING: &#039; . $err-&gt;getMessage());
                }
            } else {
                PEAR::popErrorHandling();
            }

            if (!$this-&gt;commitFileTransaction()) {
                $this-&gt;rollbackFileTransaction();
                if (!isset($options[&#039;ignore-errors&#039;])) {
                    return $this-&gt;raiseError(&quot;uninstall failed&quot;);
                }

                if (!isset($options[&#039;soft&#039;])) {
                    $this-&gt;log(0, &#039;WARNING: uninstall failed&#039;);
                }
            } else {
                $this-&gt;startFileTransaction();
                $dirtree = $pkg-&gt;getDirTree();
                if ($dirtree === false) {
                    $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
                    return $this-&gt;_registry-&gt;deletePackage($package, $channel);
                }

                // attempt to delete empty directories
                uksort($dirtree, array($this, &#039;_sortDirs&#039;));
                foreach($dirtree as $dir =&gt; $notused) {
                    $this-&gt;addFileOperation(&#039;rmdir&#039;, array($dir));
                }

                if (!$this-&gt;commitFileTransaction()) {
                    $this-&gt;rollbackFileTransaction();
                    if (!isset($options[&#039;ignore-errors&#039;])) {
                        return $this-&gt;raiseError(&quot;uninstall failed&quot;);
                    }

                    if (!isset($options[&#039;soft&#039;])) {
                        $this-&gt;log(0, &#039;WARNING: uninstall failed&#039;);
                    }
                }
            }
            // }}}
        }

        $this-&gt;configSet(&#039;default_channel&#039;, $savechannel);
        // Register that the package is no longer installed
        return $this-&gt;_registry-&gt;deletePackage($package, $channel);
    }

    /**
     * Sort a list of arrays of array(downloaded packagefilename) by dependency.
     *
     * It also removes duplicate dependencies
     * @param array an array of PEAR_PackageFile_v[1/2] objects
     * @return array|PEAR_Error array of array(packagefilename, package.xml contents)
     */
    function sortPackagesForUninstall(&amp;$packages)
    {
        $this-&gt;_dependencyDB = &amp;PEAR_DependencyDB::singleton($this-&gt;config);
        if (PEAR::isError($this-&gt;_dependencyDB)) {
            return $this-&gt;_dependencyDB;
        }
        usort($packages, array(&amp;$this, &#039;_sortUninstall&#039;));
    }

    function _sortUninstall($a, $b)
    {
        if (!$a-&gt;getDeps() &amp;&amp; !$b-&gt;getDeps()) {
            return 0; // neither package has dependencies, order is insignificant
        }
        if ($a-&gt;getDeps() &amp;&amp; !$b-&gt;getDeps()) {
            return -1; // $a must be installed after $b because $a has dependencies
        }
        if (!$a-&gt;getDeps() &amp;&amp; $b-&gt;getDeps()) {
            return 1; // $b must be installed after $a because $b has dependencies
        }
        // both packages have dependencies
        if ($this-&gt;_dependencyDB-&gt;dependsOn($a, $b)) {
            return -1;
        }
        if ($this-&gt;_dependencyDB-&gt;dependsOn($b, $a)) {
            return 1;
        }
        return 0;
    }

    // }}}
    // {{{ _sortDirs()
    function _sortDirs($a, $b)
    {
        if (strnatcmp($a, $b) == -1) return 1;
        if (strnatcmp($a, $b) == 1) return -1;
        return 0;
    }

    // }}}

    // {{{ _buildCallback()

    function _buildCallback($what, $data)
    {
        if (($what == &#039;cmdoutput&#039; &amp;&amp; $this-&gt;debug &gt; 1) ||
            ($what == &#039;output&#039; &amp;&amp; $this-&gt;debug &gt; 0)) {
            $this-&gt;ui-&gt;outputData(rtrim($data), &#039;build&#039;);
        }
    }

    // }}}
}
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>