<h2>Edit File - System.php</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/opt/alt/php71/usr/share/pear/System.php">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&lt;?php
/**
 * File/Directory manipulation
 *
 * PHP versions 4 and 5
 *
 * @category   pear
 * @package    System
 * @author     Tomas V.V.Cox &lt;cox@idecnet.com&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
 */

/**
 * base class
 */
require_once &#039;PEAR.php&#039;;
require_once &#039;Console/Getopt.php&#039;;

$GLOBALS[&#039;_System_temp_files&#039;] = array();

/**
* System offers cross platform compatible system functions
*
* Static functions for different operations. Should work under
* Unix and Windows. The names and usage has been taken from its respectively
* GNU commands. The functions will return (bool) false on error and will
* trigger the error with the PHP trigger_error() function (you can silence
* the error by prefixing a &#039;@&#039; sign after the function call, but this
* is not recommended practice.  Instead use an error handler with
* {@link set_error_handler()}).
*
* Documentation on this class you can find in:
* http://pear.php.net/manual/
*
* Example usage:
* if (!@System::rm(&#039;-r file1 dir1&#039;)) {
*    print &quot;could not delete file1 or dir1&quot;;
* }
*
* In case you need to to pass file names with spaces,
* pass the params as an array:
*
* System::rm(array(&#039;-r&#039;, $file1, $dir1));
*
* @category   pear
* @package    System
* @author     Tomas V.V. Cox &lt;cox@idecnet.com&gt;
* @copyright  1997-2006 The PHP Group
* @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
* @static
*/
class System
{
    /**
     * returns the commandline arguments of a function
     *
     * @param    string  $argv           the commandline
     * @param    string  $short_options  the allowed option short-tags
     * @param    string  $long_options   the allowed option long-tags
     * @return   array   the given options and there values
     */
    public static function _parseArgs($argv, $short_options, $long_options = null)
    {
        if (!is_array($argv) &amp;&amp; $argv !== null) {
            /*
            // Quote all items that are a short option
            $av = preg_split(&#039;/(\A| )--?[a-z0-9]+[ =]?((?&lt;!\\\\)((,\s*)|((?&lt;!,)\s+))?)/i&#039;, $argv, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE);
            $offset = 0;
            foreach ($av as $a) {
                $b = trim($a[0]);
                if ($b[0] == &#039;&quot;&#039; || $b[0] == &quot;&#039;&quot;) {
                    continue;
                }

                $escape = escapeshellarg($b);
                $pos = $a[1] + $offset;
                $argv = substr_replace($argv, $escape, $pos, strlen($b));
                $offset += 2;
            }
            */

            // Find all items, quoted or otherwise
            preg_match_all(&quot;/(?:[\&quot;&#039;])(.*?)(?:[&#039;\&quot;])|([^\s]+)/&quot;, $argv, $av);
            $argv = $av[1];
            foreach ($av[2] as $k =&gt; $a) {
                if (empty($a)) {
                    continue;
                }
                $argv[$k] = trim($a) ;
            }
        }

        return Console_Getopt::getopt2($argv, $short_options, $long_options);
    }

    /**
     * Output errors with PHP trigger_error(). You can silence the errors
     * with prefixing a &quot;@&quot; sign to the function call: @System::mkdir(..);
     *
     * @param mixed $error a PEAR error or a string with the error message
     * @return bool false
     */
    protected static function raiseError($error)
    {
        if (PEAR::isError($error)) {
            $error = $error-&gt;getMessage();
        }
        trigger_error($error, E_USER_WARNING);
        return false;
    }

    /**
     * Creates a nested array representing the structure of a directory
     *
     * System::_dirToStruct(&#039;dir1&#039;, 0) =&gt;
     *   Array
     *    (
     *    [dirs] =&gt; Array
     *        (
     *            [0] =&gt; dir1
     *        )
     *
     *    [files] =&gt; Array
     *        (
     *            [0] =&gt; dir1/file2
     *            [1] =&gt; dir1/file3
     *        )
     *    )
     * @param    string  $sPath      Name of the directory
     * @param    integer $maxinst    max. deep of the lookup
     * @param    integer $aktinst    starting deep of the lookup
     * @param    bool    $silent     if true, do not emit errors.
     * @return   array   the structure of the dir
     */
    protected static function _dirToStruct($sPath, $maxinst, $aktinst = 0, $silent = false)
    {
        $struct = array(&#039;dirs&#039; =&gt; array(), &#039;files&#039; =&gt; array());
        if (($dir = @opendir($sPath)) === false) {
            if (!$silent) {
                System::raiseError(&quot;Could not open dir $sPath&quot;);
            }
            return $struct; // XXX could not open error
        }

        $struct[&#039;dirs&#039;][] = $sPath = realpath($sPath); // XXX don&#039;t add if &#039;.&#039; or &#039;..&#039; ?
        $list = array();
        while (false !== ($file = readdir($dir))) {
            if ($file != &#039;.&#039; &amp;&amp; $file != &#039;..&#039;) {
                $list[] = $file;
            }
        }

        closedir($dir);
        natsort($list);
        if ($aktinst &lt; $maxinst || $maxinst == 0) {
            foreach ($list as $val) {
                $path = $sPath . DIRECTORY_SEPARATOR . $val;
                if (is_dir($path) &amp;&amp; !is_link($path)) {
                    $tmp    = System::_dirToStruct($path, $maxinst, $aktinst+1, $silent);
                    $struct = array_merge_recursive($struct, $tmp);
                } else {
                    $struct[&#039;files&#039;][] = $path;
                }
            }
        }

        return $struct;
    }

    /**
     * Creates a nested array representing the structure of a directory and files
     *
     * @param    array $files Array listing files and dirs
     * @return   array
     * @static
     * @see System::_dirToStruct()
     */
    protected static function _multipleToStruct($files)
    {
        $struct = array(&#039;dirs&#039; =&gt; array(), &#039;files&#039; =&gt; array());
        settype($files, &#039;array&#039;);
        foreach ($files as $file) {
            if (is_dir($file) &amp;&amp; !is_link($file)) {
                $tmp    = System::_dirToStruct($file, 0);
                $struct = array_merge_recursive($tmp, $struct);
            } else {
                if (!in_array($file, $struct[&#039;files&#039;])) {
                    $struct[&#039;files&#039;][] = $file;
                }
            }
        }
        return $struct;
    }

    /**
     * The rm command for removing files.
     * Supports multiple files and dirs and also recursive deletes
     *
     * @param    string  $args   the arguments for rm
     * @return   mixed   PEAR_Error or true for success
     * @static
     * @access   public
     */
    public static function rm($args)
    {
        $opts = System::_parseArgs($args, &#039;rf&#039;); // &quot;f&quot; does nothing but I like it :-)
        if (PEAR::isError($opts)) {
            return System::raiseError($opts);
        }
        foreach ($opts[0] as $opt) {
            if ($opt[0] == &#039;r&#039;) {
                $do_recursive = true;
            }
        }
        $ret = true;
        if (isset($do_recursive)) {
            $struct = System::_multipleToStruct($opts[1]);
            foreach ($struct[&#039;files&#039;] as $file) {
                if (!@unlink($file)) {
                    $ret = false;
                }
            }

            rsort($struct[&#039;dirs&#039;]);
            foreach ($struct[&#039;dirs&#039;] as $dir) {
                if (!@rmdir($dir)) {
                    $ret = false;
                }
            }
        } else {
            foreach ($opts[1] as $file) {
                $delete = (is_dir($file)) ? &#039;rmdir&#039; : &#039;unlink&#039;;
                if (!@$delete($file)) {
                    $ret = false;
                }
            }
        }
        return $ret;
    }

    /**
     * Make directories.
     *
     * The -p option will create parent directories
     * @param    string  $args    the name of the director(y|ies) to create
     * @return   bool    True for success
     */
    public static function mkDir($args)
    {
        $opts = System::_parseArgs($args, &#039;pm:&#039;);
        if (PEAR::isError($opts)) {
            return System::raiseError($opts);
        }

        $mode = 0777; // default mode
        foreach ($opts[0] as $opt) {
            if ($opt[0] == &#039;p&#039;) {
                $create_parents = true;
            } elseif ($opt[0] == &#039;m&#039;) {
                // if the mode is clearly an octal number (starts with 0)
                // convert it to decimal
                if (strlen($opt[1]) &amp;&amp; $opt[1][0] == &#039;0&#039;) {
                    $opt[1] = octdec($opt[1]);
                } else {
                    // convert to int
                    $opt[1] += 0;
                }
                $mode = $opt[1];
            }
        }

        $ret = true;
        if (isset($create_parents)) {
            foreach ($opts[1] as $dir) {
                $dirstack = array();
                while ((!file_exists($dir) || !is_dir($dir)) &amp;&amp;
                        $dir != DIRECTORY_SEPARATOR) {
                    array_unshift($dirstack, $dir);
                    $dir = dirname($dir);
                }

                while ($newdir = array_shift($dirstack)) {
                    if (!is_writeable(dirname($newdir))) {
                        $ret = false;
                        break;
                    }

                    if (!mkdir($newdir, $mode)) {
                        $ret = false;
                    }
                }
            }
        } else {
            foreach($opts[1] as $dir) {
                if ((@file_exists($dir) || !is_dir($dir)) &amp;&amp; !mkdir($dir, $mode)) {
                    $ret = false;
                }
            }
        }

        return $ret;
    }

    /**
     * Concatenate files
     *
     * Usage:
     * 1) $var = System::cat(&#039;sample.txt test.txt&#039;);
     * 2) System::cat(&#039;sample.txt test.txt &gt; final.txt&#039;);
     * 3) System::cat(&#039;sample.txt test.txt &gt;&gt; final.txt&#039;);
     *
     * Note: as the class use fopen, urls should work also
     *
     * @param    string  $args   the arguments
     * @return   boolean true on success
     */
    public static function &amp;cat($args)
    {
        $ret = null;
        $files = array();
        if (!is_array($args)) {
            $args = preg_split(&#039;/\s+/&#039;, $args, -1, PREG_SPLIT_NO_EMPTY);
        }

        $count_args = count($args);
        for ($i = 0; $i &lt; $count_args; $i++) {
            if ($args[$i] == &#039;&gt;&#039;) {
                $mode = &#039;wb&#039;;
                $outputfile = $args[$i+1];
                break;
            } elseif ($args[$i] == &#039;&gt;&gt;&#039;) {
                $mode = &#039;ab+&#039;;
                $outputfile = $args[$i+1];
                break;
            } else {
                $files[] = $args[$i];
            }
        }
        $outputfd = false;
        if (isset($mode)) {
            if (!$outputfd = fopen($outputfile, $mode)) {
                $err = System::raiseError(&quot;Could not open $outputfile&quot;);
                return $err;
            }
            $ret = true;
        }
        foreach ($files as $file) {
            if (!$fd = fopen($file, &#039;r&#039;)) {
                System::raiseError(&quot;Could not open $file&quot;);
                continue;
            }
            while ($cont = fread($fd, 2048)) {
                if (is_resource($outputfd)) {
                    fwrite($outputfd, $cont);
                } else {
                    $ret .= $cont;
                }
            }
            fclose($fd);
        }
        if (is_resource($outputfd)) {
            fclose($outputfd);
        }
        return $ret;
    }

    /**
     * Creates temporary files or directories. This function will remove
     * the created files when the scripts finish its execution.
     *
     * Usage:
     *   1) $tempfile = System::mktemp(&quot;prefix&quot;);
     *   2) $tempdir  = System::mktemp(&quot;-d prefix&quot;);
     *   3) $tempfile = System::mktemp();
     *   4) $tempfile = System::mktemp(&quot;-t /var/tmp prefix&quot;);
     *
     * prefix -&gt; The string that will be prepended to the temp name
     *           (defaults to &quot;tmp&quot;).
     * -d     -&gt; A temporary dir will be created instead of a file.
     * -t     -&gt; The target dir where the temporary (file|dir) will be created. If
     *           this param is missing by default the env vars TMP on Windows or
     *           TMPDIR in Unix will be used. If these vars are also missing
     *           c:\windows\temp or /tmp will be used.
     *
     * @param   string  $args  The arguments
     * @return  mixed   the full path of the created (file|dir) or false
     * @see System::tmpdir()
     */
    public static function mktemp($args = null)
    {
        static $first_time = true;
        $opts = System::_parseArgs($args, &#039;t:d&#039;);
        if (PEAR::isError($opts)) {
            return System::raiseError($opts);
        }

        foreach ($opts[0] as $opt) {
            if ($opt[0] == &#039;d&#039;) {
                $tmp_is_dir = true;
            } elseif ($opt[0] == &#039;t&#039;) {
                $tmpdir = $opt[1];
            }
        }

        $prefix = (isset($opts[1][0])) ? $opts[1][0] : &#039;tmp&#039;;
        if (!isset($tmpdir)) {
            $tmpdir = System::tmpdir();
        }

        if (!System::mkDir(array(&#039;-p&#039;, $tmpdir))) {
            return false;
        }

        $tmp = tempnam($tmpdir, $prefix);
        if (isset($tmp_is_dir)) {
            unlink($tmp); // be careful possible race condition here
            if (!mkdir($tmp, 0700)) {
                return System::raiseError(&quot;Unable to create temporary directory $tmpdir&quot;);
            }
        }

        $GLOBALS[&#039;_System_temp_files&#039;][] = $tmp;
        if (isset($tmp_is_dir)) {
            //$GLOBALS[&#039;_System_temp_files&#039;][] = dirname($tmp);
        }

        if ($first_time) {
            PEAR::registerShutdownFunc(array(&#039;System&#039;, &#039;_removeTmpFiles&#039;));
            $first_time = false;
        }

        return $tmp;
    }

    /**
     * Remove temporary files created my mkTemp. This function is executed
     * at script shutdown time
     */
    public static function _removeTmpFiles()
    {
        if (count($GLOBALS[&#039;_System_temp_files&#039;])) {
            $delete = $GLOBALS[&#039;_System_temp_files&#039;];
            array_unshift($delete, &#039;-r&#039;);
            System::rm($delete);
            $GLOBALS[&#039;_System_temp_files&#039;] = array();
        }
    }

    /**
     * Get the path of the temporal directory set in the system
     * by looking in its environments variables.
     * Note: php.ini-recommended removes the &quot;E&quot; from the variables_order setting,
     * making unavaible the $_ENV array, that s why we do tests with _ENV
     *
     * @return string The temporary directory on the system
     */
    public static function tmpdir()
    {
        if (OS_WINDOWS) {
            if ($var = isset($_ENV[&#039;TMP&#039;]) ? $_ENV[&#039;TMP&#039;] : getenv(&#039;TMP&#039;)) {
                return $var;
            }
            if ($var = isset($_ENV[&#039;TEMP&#039;]) ? $_ENV[&#039;TEMP&#039;] : getenv(&#039;TEMP&#039;)) {
                return $var;
            }
            if ($var = isset($_ENV[&#039;USERPROFILE&#039;]) ? $_ENV[&#039;USERPROFILE&#039;] : getenv(&#039;USERPROFILE&#039;)) {
                return $var;
            }
            if ($var = isset($_ENV[&#039;windir&#039;]) ? $_ENV[&#039;windir&#039;] : getenv(&#039;windir&#039;)) {
                return $var;
            }
            return getenv(&#039;SystemRoot&#039;) . &#039;\temp&#039;;
        }
        if ($var = isset($_ENV[&#039;TMPDIR&#039;]) ? $_ENV[&#039;TMPDIR&#039;] : getenv(&#039;TMPDIR&#039;)) {
            return $var;
        }
        return realpath(function_exists(&#039;sys_get_temp_dir&#039;) ? sys_get_temp_dir() : &#039;/tmp&#039;);
    }

    /**
     * The &quot;which&quot; command (show the full path of a command)
     *
     * @param string $program The command to search for
     * @param mixed  $fallback Value to return if $program is not found
     *
     * @return mixed A string with the full path or false if not found
     * @author Stig Bakken &lt;ssb@php.net&gt;
     */
    public static function which($program, $fallback = false)
    {
        // enforce API
        if (!is_string($program) || &#039;&#039; == $program) {
            return $fallback;
        }

        // full path given
        if (basename($program) != $program) {
            $path_elements[] = dirname($program);
            $program = basename($program);
        } else {
            $path = getenv(&#039;PATH&#039;);
            if (!$path) {
                $path = getenv(&#039;Path&#039;); // some OSes are just stupid enough to do this
            }

            $path_elements = explode(PATH_SEPARATOR, $path);
        }

        if (OS_WINDOWS) {
            $exe_suffixes = getenv(&#039;PATHEXT&#039;)
                                ? explode(PATH_SEPARATOR, getenv(&#039;PATHEXT&#039;))
                                : array(&#039;.exe&#039;,&#039;.bat&#039;,&#039;.cmd&#039;,&#039;.com&#039;);
            // allow passing a command.exe param
            if (strpos($program, &#039;.&#039;) !== false) {
                array_unshift($exe_suffixes, &#039;&#039;);
            }
        } else {
            $exe_suffixes = array(&#039;&#039;);
        }

        foreach ($exe_suffixes as $suff) {
            foreach ($path_elements as $dir) {
                $file = $dir . DIRECTORY_SEPARATOR . $program . $suff;
                // It&#039;s possible to run a .bat on Windows that is_executable
                // would return false for. The is_executable check is meaningless...
                if (OS_WINDOWS) {
                    if (file_exists($file)) {
                        return $file;
                    }
                } else {
                    if (is_executable($file)) {
                        return $file;
                    }
                }
            }
        }
        return $fallback;
    }

    /**
     * The &quot;find&quot; command
     *
     * Usage:
     *
     * System::find($dir);
     * System::find(&quot;$dir -type d&quot;);
     * System::find(&quot;$dir -type f&quot;);
     * System::find(&quot;$dir -name *.php&quot;);
     * System::find(&quot;$dir -name *.php -name *.htm*&quot;);
     * System::find(&quot;$dir -maxdepth 1&quot;);
     *
     * Params implemented:
     * $dir            -&gt; Start the search at this directory
     * -type d         -&gt; return only directories
     * -type f         -&gt; return only files
     * -maxdepth &lt;n&gt;   -&gt; max depth of recursion
     * -name &lt;pattern&gt; -&gt; search pattern (bash style). Multiple -name param allowed
     *
     * @param  mixed Either array or string with the command line
     * @return array Array of found files
     */
    public static function find($args)
    {
        if (!is_array($args)) {
            $args = preg_split(&#039;/\s+/&#039;, $args, -1, PREG_SPLIT_NO_EMPTY);
        }
        $dir = realpath(array_shift($args));
        if (!$dir) {
            return array();
        }
        $patterns = array();
        $depth = 0;
        $do_files = $do_dirs = true;
        $args_count = count($args);
        for ($i = 0; $i &lt; $args_count; $i++) {
            switch ($args[$i]) {
                case &#039;-type&#039;:
                    if (in_array($args[$i+1], array(&#039;d&#039;, &#039;f&#039;))) {
                        if ($args[$i+1] == &#039;d&#039;) {
                            $do_files = false;
                        } else {
                            $do_dirs = false;
                        }
                    }
                    $i++;
                    break;
                case &#039;-name&#039;:
                    $name = preg_quote($args[$i+1], &#039;#&#039;);
                    // our magic characters ? and * have just been escaped,
                    // so now we change the escaped versions to PCRE operators
                    $name = strtr($name, array(&#039;\?&#039; =&gt; &#039;.&#039;, &#039;\*&#039; =&gt; &#039;.*&#039;));
                    $patterns[] = &#039;(&#039;.$name.&#039;)&#039;;
                    $i++;
                    break;
                case &#039;-maxdepth&#039;:
                    $depth = $args[$i+1];
                    break;
            }
        }
        $path = System::_dirToStruct($dir, $depth, 0, true);
        if ($do_files &amp;&amp; $do_dirs) {
            $files = array_merge($path[&#039;files&#039;], $path[&#039;dirs&#039;]);
        } elseif ($do_dirs) {
            $files = $path[&#039;dirs&#039;];
        } else {
            $files = $path[&#039;files&#039;];
        }
        if (count($patterns)) {
            $dsq = preg_quote(DIRECTORY_SEPARATOR, &#039;#&#039;);
            $pattern = &#039;#(^|&#039;.$dsq.&#039;)&#039;.implode(&#039;|&#039;, $patterns).&#039;($|&#039;.$dsq.&#039;)#&#039;;
            $ret = array();
            $files_count = count($files);
            for ($i = 0; $i &lt; $files_count; $i++) {
                // only search in the part of the file below the current directory
                $filepart = basename($files[$i]);
                if (preg_match($pattern, $filepart)) {
                    $ret[] = $files[$i];
                }
            }
            return $ret;
        }
        return $files;
    }
}
</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>