Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:37
📁 Exception	-	2025-05-25 12:37
📄 ExecutableFinder.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Process; /* * Generic executable finder. * * @author Fabien Potencier <fabien@symfony.com> * @author Johannes M. Schmitt <schmittjoh@gmail.com> / class ExecutableFinder { private $suffixes = array('.exe', '.bat', '.cmd', '.com'); /* * Replaces default suffixes of executable. * * @param array $suffixes / public function setSuffixes(array $suffixes) { $this->suffixes = $suffixes; } /* * Adds new possible suffix to check for executable. * * @param string $suffix / public function addSuffix($suffix) { $this->suffixes[] = $suffix; } /* * Finds an executable by name. * * @param string $name The executable name (without the extension) * @param string $default The default to return if no executable is found * @param array $extraDirs Additional dirs to check into * * @return string The executable path or default value */ public function find($name, $default = null, array $extraDirs = array()) { if (ini_get('open_basedir')) { $searchPath = explode(PATH_SEPARATOR, getenv('open_basedir')); $dirs = array(); foreach ($searchPath as $path) { if (is_dir($path)) { $dirs[] = $path; } else { $file = str_replace(dirname($path), '', $path); if ($file == $name && is_executable($path)) { return $path; } } } } else { $dirs = array_merge( explode(PATH_SEPARATOR, getenv('PATH') ?: getenv('Path')), $extraDirs ); } $suffixes = array(''); if (defined('PHP_WINDOWS_VERSION_BUILD')) { $pathExt = getenv('PATHEXT'); $suffixes = $pathExt ? explode(PATH_SEPARATOR, $pathExt) : $this->suffixes; } foreach ($suffixes as $suffix) { foreach ($dirs as $dir) { if (is_file($file = $dir.DIRECTORY_SEPARATOR.$name.$suffix) && (defined('PHP_WINDOWS_VERSION_BUILD') \|\| is_executable($file))) { return $file; } } } return $default; } }	2.52 KB	2024-07-17 10:22
📄 PhpExecutableFinder.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Process; /* * An executable finder specifically designed for the PHP executable. * * @author Fabien Potencier <fabien@symfony.com> * @author Johannes M. Schmitt <schmittjoh@gmail.com> / class PhpExecutableFinder { private $executableFinder; public function __construct() { $this->executableFinder = new ExecutableFinder(); } /* * Finds The PHP executable. * * @return string\|false The PHP executable path or false if it cannot be found */ public function find() { // HHVM support if (defined('HHVM_VERSION') && false !== $hhvm = getenv('PHP_BINARY')) { return $hhvm; } // PHP_BINARY return the current sapi executable if (defined('PHP_BINARY') && PHP_BINARY && in_array(PHP_SAPI, array('cli', 'cli-server')) && is_file(PHP_BINARY)) { return PHP_BINARY; } if ($php = getenv('PHP_PATH')) { if (!is_executable($php)) { return false; } return $php; } if ($php = getenv('PHP_PEAR_PHP_BIN')) { if (is_executable($php)) { return $php; } } $dirs = array(PHP_BINDIR); if (defined('PHP_WINDOWS_VERSION_BUILD')) { $dirs[] = 'C:\xampp\php\\'; } return $this->executableFinder->find('php', false, $dirs); } }	1.64 KB	2024-07-17 10:22
📄 PhpProcess.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Process; use Symfony\Component\Process\Exception\RuntimeException; /* * PhpProcess runs a PHP script in an independent process. * * $p = new PhpProcess('<?php echo "foo"; ?>'); * $p->run(); * print $p->getOutput()."\n"; * * @author Fabien Potencier <fabien@symfony.com> * * @api / class PhpProcess extends Process { private $executableFinder; /* * Constructor. * * @param string $script The PHP script to run (as a string) * @param string $cwd The working directory * @param array $env The environment variables * @param integer $timeout The timeout in seconds * @param array $options An array of options for proc_open * * @api / public function __construct($script, $cwd = null, array $env = array(), $timeout = 60, array $options = array()) { parent::__construct(null, $cwd, $env, $script, $timeout, $options); $this->executableFinder = new PhpExecutableFinder(); } /* * Sets the path to the PHP binary to use. * * @api / public function setPhpBinary($php) { $this->setCommandLine($php); } /* * {@inheritdoc} */ public function start($callback = null) { if (null === $this->getCommandLine()) { if (false === $php = $this->executableFinder->find()) { throw new RuntimeException('Unable to find the PHP executable.'); } $this->setCommandLine($php); } parent::start($callback); } }	1.78 KB	2024-07-17 10:22
📄 Process.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Process; use Symfony\Component\Process\Exception\InvalidArgumentException; use Symfony\Component\Process\Exception\LogicException; use Symfony\Component\Process\Exception\ProcessTimedOutException; use Symfony\Component\Process\Exception\RuntimeException; /* * Process is a thin wrapper around proc_* functions to easily * start independent PHP processes. * * @author Fabien Potencier <fabien@symfony.com> * * @api / class Process { const ERR = 'err'; const OUT = 'out'; const STATUS_READY = 'ready'; const STATUS_STARTED = 'started'; const STATUS_TERMINATED = 'terminated'; const STDIN = 0; const STDOUT = 1; const STDERR = 2; // Timeout Precision in seconds. const TIMEOUT_PRECISION = 0.2; private $callback; private $commandline; private $cwd; private $env; private $stdin; private $starttime; private $lastOutputTime; private $timeout; private $idleTimeout; private $options; private $exitcode; private $fallbackExitcode; private $processInformation; private $stdout; private $stderr; private $enhanceWindowsCompatibility; private $enhanceSigchildCompatibility; private $process; private $status = self::STATUS_READY; private $incrementalOutputOffset = 0; private $incrementalErrorOutputOffset = 0; private $tty; private $useFileHandles = false; /* @var ProcessPipes / private $processPipes; private static $sigchild; /* * Exit codes translation table. * * User-defined errors must use exit codes in the 64-113 range. * * @var array / public static $exitCodes = array( 0 => 'OK', 1 => 'General error', 2 => 'Misuse of shell builtins', 126 => 'Invoked command cannot execute', 127 => 'Command not found', 128 => 'Invalid exit argument', // signals 129 => 'Hangup', 130 => 'Interrupt', 131 => 'Quit and dump core', 132 => 'Illegal instruction', 133 => 'Trace/breakpoint trap', 134 => 'Process aborted', 135 => 'Bus error: "access to undefined portion of memory object"', 136 => 'Floating point exception: "erroneous arithmetic operation"', 137 => 'Kill (terminate immediately)', 138 => 'User-defined 1', 139 => 'Segmentation violation', 140 => 'User-defined 2', 141 => 'Write to pipe with no one reading', 142 => 'Signal raised by alarm', 143 => 'Termination (request to terminate)', // 144 - not defined 145 => 'Child process terminated, stopped (or continued)', 146 => 'Continue if stopped', 147 => 'Stop executing temporarily', 148 => 'Terminal stop signal', 149 => 'Background process attempting to read from tty ("in")', 150 => 'Background process attempting to write to tty ("out")', 151 => 'Urgent data available on socket', 152 => 'CPU time limit exceeded', 153 => 'File size limit exceeded', 154 => 'Signal raised by timer counting virtual time: "virtual timer expired"', 155 => 'Profiling timer expired', // 156 - not defined 157 => 'Pollable event', // 158 - not defined 159 => 'Bad syscall', ); /** * Constructor. * * @param string $commandline The command line to run * @param string\|null $cwd The working directory or null to use the working dir of the current PHP process * @param array\|null $env The environment variables or null to inherit * @param string\|null $stdin The STDIN content * @param integer\|float\|null $timeout The timeout in seconds or null to disable * @param array $options An array of options for proc_open * * @throws RuntimeException When proc_open is not installed * * @api / public function __construct($commandline, $cwd = null, array $env = null, $stdin = null, $timeout = 60, array $options = array()) { if (!function_exists('proc_open')) { throw new RuntimeException('The Process class relies on proc_open, which is not available on your PHP installation.'); } $this->commandline = $commandline; $this->cwd = $cwd; // on Windows, if the cwd changed via chdir(), proc_open defaults to the dir where PHP was started // on Gnu/Linux, PHP builds with --enable-maintainer-zts are also affected // @see : https://bugs.php.net/bug.php?id=51800 // @see : https://bugs.php.net/bug.php?id=50524 if (null === $this->cwd && (defined('ZEND_THREAD_SAFE') \|\| defined('PHP_WINDOWS_VERSION_BUILD'))) { $this->cwd = getcwd(); } if (null !== $env) { $this->setEnv($env); } else { $this->env = null; } $this->stdin = $stdin; $this->setTimeout($timeout); $this->useFileHandles = defined('PHP_WINDOWS_VERSION_BUILD'); $this->enhanceWindowsCompatibility = true; $this->enhanceSigchildCompatibility = !defined('PHP_WINDOWS_VERSION_BUILD') && $this->isSigchildEnabled(); $this->options = array_replace(array('suppress_errors' => true, 'binary_pipes' => true), $options); } public function __destruct() { // stop() will check if we have a process running. $this->stop(); } public function __clone() { $this->resetProcessData(); } /* * Runs the process. * * The callback receives the type of output (out or err) and * some bytes from the output in real-time. It allows to have feedback * from the independent process during execution. * * The STDOUT and STDERR are also available after the process is finished * via the getOutput() and getErrorOutput() methods. * * @param callable\|null $callback A PHP callback to run whenever there is some * output available on STDOUT or STDERR * * @return integer The exit status code * * @throws RuntimeException When process can't be launched * @throws RuntimeException When process stopped after receiving signal * * @api / public function run($callback = null) { $this->start($callback); return $this->wait(); } /* * Starts the process and returns after sending the STDIN. * * This method blocks until all STDIN data is sent to the process then it * returns while the process runs in the background. * * The termination of the process can be awaited with wait(). * * The callback receives the type of output (out or err) and some bytes from * the output in real-time while writing the standard input to the process. * It allows to have feedback from the independent process during execution. * If there is no callback passed, the wait() method can be called * with true as a second parameter then the callback will get all data occurred * in (and since) the start call. * * @param callable\|null $callback A PHP callback to run whenever there is some * output available on STDOUT or STDERR * * @return Process The process itself * * @throws RuntimeException When process can't be launched * @throws RuntimeException When process is already running / public function start($callback = null) { if ($this->isRunning()) { throw new RuntimeException('Process is already running'); } $this->resetProcessData(); $this->starttime = $this->lastOutputTime = microtime(true); $this->callback = $this->buildCallback($callback); $descriptors = $this->getDescriptors(); $commandline = $this->commandline; if (defined('PHP_WINDOWS_VERSION_BUILD') && $this->enhanceWindowsCompatibility) { $commandline = 'cmd /V:ON /E:ON /C "('.$commandline.')"'; foreach ($this->processPipes->getFiles() as $offset => $filename) { $commandline .= ' '.$offset.'>'.$filename; } if (!isset($this->options['bypass_shell'])) { $this->options['bypass_shell'] = true; } } $this->process = proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $this->env, $this->options); if (!is_resource($this->process)) { throw new RuntimeException('Unable to launch a new process.'); } $this->status = self::STATUS_STARTED; $this->processPipes->unblock(); if ($this->tty) { return; } $this->processPipes->write(false, $this->stdin); $this->updateStatus(false); $this->checkTimeout(); } /* * Restarts the process. * * Be warned that the process is cloned before being started. * * @param callable\|null $callback A PHP callback to run whenever there is some * output available on STDOUT or STDERR * * @return Process The new process * * @throws RuntimeException When process can't be launched * @throws RuntimeException When process is already running * * @see start() / public function restart($callback = null) { if ($this->isRunning()) { throw new RuntimeException('Process is already running'); } $process = clone $this; $process->start($callback); return $process; } /* * Waits for the process to terminate. * * The callback receives the type of output (out or err) and some bytes * from the output in real-time while writing the standard input to the process. * It allows to have feedback from the independent process during execution. * * @param callable\|null $callback A valid PHP callback * * @return integer The exitcode of the process * * @throws RuntimeException When process timed out * @throws RuntimeException When process stopped after receiving signal * @throws LogicException When process is not yet started / public function wait($callback = null) { $this->requireProcessIsStarted(__FUNCTION__); $this->updateStatus(false); if (null !== $callback) { $this->callback = $this->buildCallback($callback); } do { $this->checkTimeout(); $running = defined('PHP_WINDOWS_VERSION_BUILD') ? $this->isRunning() : $this->processPipes->hasOpenHandles(); $close = !defined('PHP_WINDOWS_VERSION_BUILD') \|\| !$running;; $this->readPipes(true, $close); } while ($running); while ($this->isRunning()) { usleep(1000); } if ($this->processInformation['signaled']) { throw new RuntimeException(sprintf('The process has been signaled with signal "%s".', $this->processInformation['termsig'])); } return $this->exitcode; } /* * Returns the Pid (process identifier), if applicable. * * @return integer\|null The process id if running, null otherwise * * @throws RuntimeException In case --enable-sigchild is activated / public function getPid() { if ($this->isSigchildEnabled()) { throw new RuntimeException('This PHP has been compiled with --enable-sigchild. The process identifier can not be retrieved.'); } $this->updateStatus(false); return $this->isRunning() ? $this->processInformation['pid'] : null; } /* * Sends a POSIX signal to the process. * * @param integer $signal A valid POSIX signal (see http://www.php.net/manual/en/pcntl.constants.php) * * @return Process * * @throws LogicException In case the process is not running * @throws RuntimeException In case --enable-sigchild is activated * @throws RuntimeException In case of failure / public function signal($signal) { $this->doSignal($signal, true); return $this; } /* * Returns the current output of the process (STDOUT). * * @return string The process output * * @throws LogicException In case the process is not started * * @api / public function getOutput() { $this->requireProcessIsStarted(__FUNCTION__); $this->readPipes(false, defined('PHP_WINDOWS_VERSION_BUILD') ? !$this->processInformation['running'] : true); return $this->stdout; } /* * Returns the output incrementally. * * In comparison with the getOutput method which always return the whole * output, this one returns the new output since the last call. * * @throws LogicException In case the process is not started * * @return string The process output since the last call / public function getIncrementalOutput() { $this->requireProcessIsStarted(__FUNCTION__); $data = $this->getOutput(); $latest = substr($data, $this->incrementalOutputOffset); $this->incrementalOutputOffset = strlen($data); return $latest; } /* * Clears the process output. * * @return Process / public function clearOutput() { $this->stdout = ''; $this->incrementalOutputOffset = 0; return $this; } /* * Returns the current error output of the process (STDERR). * * @return string The process error output * * @throws LogicException In case the process is not started * * @api / public function getErrorOutput() { $this->requireProcessIsStarted(__FUNCTION__); $this->readPipes(false, defined('PHP_WINDOWS_VERSION_BUILD') ? !$this->processInformation['running'] : true); return $this->stderr; } /* * Returns the errorOutput incrementally. * * In comparison with the getErrorOutput method which always return the * whole error output, this one returns the new error output since the last * call. * * @throws LogicException In case the process is not started * * @return string The process error output since the last call / public function getIncrementalErrorOutput() { $this->requireProcessIsStarted(__FUNCTION__); $data = $this->getErrorOutput(); $latest = substr($data, $this->incrementalErrorOutputOffset); $this->incrementalErrorOutputOffset = strlen($data); return $latest; } /* * Clears the process output. * * @return Process / public function clearErrorOutput() { $this->stderr = ''; $this->incrementalErrorOutputOffset = 0; return $this; } /* * Returns the exit code returned by the process. * * @return null\|integer The exit status code, null if the Process is not terminated * * @throws RuntimeException In case --enable-sigchild is activated and the sigchild compatibility mode is disabled * * @api / public function getExitCode() { if ($this->isSigchildEnabled() && !$this->enhanceSigchildCompatibility) { throw new RuntimeException('This PHP has been compiled with --enable-sigchild. You must use setEnhanceSigchildCompatibility() to use this method.'); } $this->updateStatus(false); return $this->exitcode; } /* * Returns a string representation for the exit code returned by the process. * * This method relies on the Unix exit code status standardization * and might not be relevant for other operating systems. * * @return null\|string A string representation for the exit status code, null if the Process is not terminated. * * @throws RuntimeException In case --enable-sigchild is activated and the sigchild compatibility mode is disabled * * @see http://tldp.org/LDP/abs/html/exitcodes.html * @see http://en.wikipedia.org/wiki/Unix_signal / public function getExitCodeText() { if (null === $exitcode = $this->getExitCode()) { return; } return isset(self::$exitCodes[$exitcode]) ? self::$exitCodes[$exitcode] : 'Unknown error'; } /* * Checks if the process ended successfully. * * @return Boolean true if the process ended successfully, false otherwise * * @api / public function isSuccessful() { return 0 === $this->getExitCode(); } /* * Returns true if the child process has been terminated by an uncaught signal. * * It always returns false on Windows. * * @return Boolean * * @throws RuntimeException In case --enable-sigchild is activated * @throws LogicException In case the process is not terminated * * @api / public function hasBeenSignaled() { $this->requireProcessIsTerminated(__FUNCTION__); if ($this->isSigchildEnabled()) { throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.'); } $this->updateStatus(false); return $this->processInformation['signaled']; } /* * Returns the number of the signal that caused the child process to terminate its execution. * * It is only meaningful if hasBeenSignaled() returns true. * * @return integer * * @throws RuntimeException In case --enable-sigchild is activated * @throws LogicException In case the process is not terminated * * @api / public function getTermSignal() { $this->requireProcessIsTerminated(__FUNCTION__); if ($this->isSigchildEnabled()) { throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.'); } $this->updateStatus(false); return $this->processInformation['termsig']; } /* * Returns true if the child process has been stopped by a signal. * * It always returns false on Windows. * * @return Boolean * * @throws LogicException In case the process is not terminated * * @api / public function hasBeenStopped() { $this->requireProcessIsTerminated(__FUNCTION__); $this->updateStatus(false); return $this->processInformation['stopped']; } /* * Returns the number of the signal that caused the child process to stop its execution. * * It is only meaningful if hasBeenStopped() returns true. * * @return integer * * @throws LogicException In case the process is not terminated * * @api / public function getStopSignal() { $this->requireProcessIsTerminated(__FUNCTION__); $this->updateStatus(false); return $this->processInformation['stopsig']; } /* * Checks if the process is currently running. * * @return Boolean true if the process is currently running, false otherwise / public function isRunning() { if (self::STATUS_STARTED !== $this->status) { return false; } $this->updateStatus(false); return $this->processInformation['running']; } /* * Checks if the process has been started with no regard to the current state. * * @return Boolean true if status is ready, false otherwise / public function isStarted() { return $this->status != self::STATUS_READY; } /* * Checks if the process is terminated. * * @return Boolean true if process is terminated, false otherwise / public function isTerminated() { $this->updateStatus(false); return $this->status == self::STATUS_TERMINATED; } /* * Gets the process status. * * The status is one of: ready, started, terminated. * * @return string The current process status / public function getStatus() { $this->updateStatus(false); return $this->status; } /* * Stops the process. * * @param integer\|float $timeout The timeout in seconds * @param integer $signal A POSIX signal to send in case the process has not stop at timeout, default is SIGKILL * * @return integer The exit-code of the process * * @throws RuntimeException if the process got signaled / public function stop($timeout = 10, $signal = null) { $timeoutMicro = microtime(true) + $timeout; if ($this->isRunning()) { if (defined('PHP_WINDOWS_VERSION_BUILD') && !$this->isSigchildEnabled()) { exec(sprintf("taskkill /F /T /PID %d 2>&1", $this->getPid()), $output, $exitCode); if ($exitCode > 0) { throw new RuntimeException('Unable to kill the process'); } } proc_terminate($this->process); do { usleep(1000); } while ($this->isRunning() && microtime(true) < $timeoutMicro); if ($this->isRunning() && !$this->isSigchildEnabled()) { if (null !== $signal \|\| defined('SIGKILL')) { // avoid exception here : // process is supposed to be running, but it might have stop // just after this line. // in any case, let's silently discard the error, we can not do anything $this->doSignal($signal ?: SIGKILL, false); } } } $this->updateStatus(false); if ($this->processInformation['running']) { $this->close(); } return $this->exitcode; } /* * Adds a line to the STDOUT stream. * * @param string $line The line to append / public function addOutput($line) { $this->lastOutputTime = microtime(true); $this->stdout .= $line; } /* * Adds a line to the STDERR stream. * * @param string $line The line to append / public function addErrorOutput($line) { $this->lastOutputTime = microtime(true); $this->stderr .= $line; } /* * Gets the command line to be executed. * * @return string The command to execute / public function getCommandLine() { return $this->commandline; } /* * Sets the command line to be executed. * * @param string $commandline The command to execute * * @return self The current Process instance / public function setCommandLine($commandline) { $this->commandline = $commandline; return $this; } /* * Gets the process timeout (max. runtime). * * @return float\|null The timeout in seconds or null if it's disabled / public function getTimeout() { return $this->timeout; } /* * Gets the process idle timeout (max. time since last output). * * @return float\|null The timeout in seconds or null if it's disabled / public function getIdleTimeout() { return $this->idleTimeout; } /* * Sets the process timeout (max. runtime). * * To disable the timeout, set this value to null. * * @param integer\|float\|null $timeout The timeout in seconds * * @return self The current Process instance * * @throws InvalidArgumentException if the timeout is negative / public function setTimeout($timeout) { $this->timeout = $this->validateTimeout($timeout); return $this; } /* * Sets the process idle timeout (max. time since last output). * * To disable the timeout, set this value to null. * * @param integer\|float\|null $timeout The timeout in seconds * * @return self The current Process instance. * * @throws InvalidArgumentException if the timeout is negative / public function setIdleTimeout($timeout) { $this->idleTimeout = $this->validateTimeout($timeout); return $this; } /* * Enables or disables the TTY mode. * * @param boolean $tty True to enabled and false to disable * * @return self The current Process instance / public function setTty($tty) { $this->tty = (Boolean) $tty; return $this; } /* * Checks if the TTY mode is enabled. * * @return Boolean true if the TTY mode is enabled, false otherwise / public function isTty() { return $this->tty; } /* * Gets the working directory. * * @return string\|null The current working directory or null on failure / public function getWorkingDirectory() { if (null === $this->cwd) { // getcwd() will return false if any one of the parent directories does not have // the readable or search mode set, even if the current directory does return getcwd() ?: null; } return $this->cwd; } /* * Sets the current working directory. * * @param string $cwd The new working directory * * @return self The current Process instance / public function setWorkingDirectory($cwd) { $this->cwd = $cwd; return $this; } /* * Gets the environment variables. * * @return array The current environment variables / public function getEnv() { return $this->env; } /* * Sets the environment variables. * * An environment variable value should be a string. * If it is an array, the variable is ignored. * * That happens in PHP when 'argv' is registered into * the $_ENV array for instance. * * @param array $env The new environment variables * * @return self The current Process instance / public function setEnv(array $env) { // Process can not handle env values that are arrays $env = array_filter($env, function ($value) { return !is_array($value); }); $this->env = array(); foreach ($env as $key => $value) { $this->env[(binary) $key] = (binary) $value; } return $this; } /* * Gets the contents of STDIN. * * @return string\|null The current contents / public function getStdin() { return $this->stdin; } /* * Sets the contents of STDIN. * * @param string\|null $stdin The new contents * * @return self The current Process instance / public function setStdin($stdin) { $this->stdin = $stdin; return $this; } /* * Gets the options for proc_open. * * @return array The current options / public function getOptions() { return $this->options; } /* * Sets the options for proc_open. * * @param array $options The new options * * @return self The current Process instance / public function setOptions(array $options) { $this->options = $options; return $this; } /* * Gets whether or not Windows compatibility is enabled. * * This is true by default. * * @return Boolean / public function getEnhanceWindowsCompatibility() { return $this->enhanceWindowsCompatibility; } /* * Sets whether or not Windows compatibility is enabled. * * @param Boolean $enhance * * @return self The current Process instance / public function setEnhanceWindowsCompatibility($enhance) { $this->enhanceWindowsCompatibility = (Boolean) $enhance; return $this; } /* * Returns whether sigchild compatibility mode is activated or not. * * @return Boolean / public function getEnhanceSigchildCompatibility() { return $this->enhanceSigchildCompatibility; } /* * Activates sigchild compatibility mode. * * Sigchild compatibility mode is required to get the exit code and * determine the success of a process when PHP has been compiled with * the --enable-sigchild option * * @param Boolean $enhance * * @return self The current Process instance / public function setEnhanceSigchildCompatibility($enhance) { $this->enhanceSigchildCompatibility = (Boolean) $enhance; return $this; } /* * Performs a check between the timeout definition and the time the process started. * * In case you run a background process (with the start method), you should * trigger this method regularly to ensure the process timeout * * @throws ProcessTimedOutException In case the timeout was reached / public function checkTimeout() { if ($this->status !== self::STATUS_STARTED) { return; } if (null !== $this->timeout && $this->timeout < microtime(true) - $this->starttime) { $this->stop(0); throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_GENERAL); } if (null !== $this->idleTimeout && $this->idleTimeout < microtime(true) - $this->lastOutputTime) { $this->stop(0); throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_IDLE); } } /* * Creates the descriptors needed by the proc_open. * * @return array / private function getDescriptors() { $this->processPipes = new ProcessPipes($this->useFileHandles, $this->tty); $descriptors = $this->processPipes->getDescriptors(); if (!$this->useFileHandles && $this->enhanceSigchildCompatibility && $this->isSigchildEnabled()) { // last exit code is output on the fourth pipe and caught to work around --enable-sigchild $descriptors = array_merge($descriptors, array(array('pipe', 'w'))); $this->commandline = '('.$this->commandline.') 3>/dev/null; code=$?; echo $code >&3; exit $code'; } return $descriptors; } /* * Builds up the callback used by wait(). * * The callbacks adds all occurred output to the specific buffer and calls * the user callback (if present) with the received output. * * @param callable\|null $callback The user defined PHP callback * * @return callable A PHP callable / protected function buildCallback($callback) { $that = $this; $out = self::OUT; $err = self::ERR; $callback = function ($type, $data) use ($that, $callback, $out, $err) { if ($out == $type) { $that->addOutput($data); } else { $that->addErrorOutput($data); } if (null !== $callback) { call_user_func($callback, $type, $data); } }; return $callback; } /* * Updates the status of the process, reads pipes. * * @param Boolean $blocking Whether to use a blocking read call. / protected function updateStatus($blocking) { if (self::STATUS_STARTED !== $this->status) { return; } $this->processInformation = proc_get_status($this->process); $this->captureExitCode(); $this->readPipes($blocking, defined('PHP_WINDOWS_VERSION_BUILD') ? !$this->processInformation['running'] : true); if (!$this->processInformation['running']) { $this->close(); } } /* * Returns whether PHP has been compiled with the '--enable-sigchild' option or not. * * @return Boolean / protected function isSigchildEnabled() { if (null !== self::$sigchild) { return self::$sigchild; } if (!function_exists('phpinfo')) { return self::$sigchild = false; } ob_start(); phpinfo(INFO_GENERAL); return self::$sigchild = false !== strpos(ob_get_clean(), '--enable-sigchild'); } /* * Validates and returns the filtered timeout. * * @param integer\|float\|null $timeout * * @return float\|null / private function validateTimeout($timeout) { $timeout = (float) $timeout; if (0.0 === $timeout) { $timeout = null; } elseif ($timeout < 0) { throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.'); } return $timeout; } /* * Reads pipes, executes callback. * * @param Boolean $blocking Whether to use blocking calls or not. * @param Boolean $close Whether to close file handles or not. / private function readPipes($blocking, $close) { if ($close) { $result = $this->processPipes->readAndCloseHandles($blocking); } else { $result = $this->processPipes->read($blocking); } foreach ($result as $type => $data) { if (3 == $type) { $this->fallbackExitcode = (int) $data; } else { call_user_func($this->callback, $type === self::STDOUT ? self::OUT : self::ERR, $data); } } } /* * Captures the exitcode if mentioned in the process information. / private function captureExitCode() { if (isset($this->processInformation['exitcode']) && -1 != $this->processInformation['exitcode']) { $this->exitcode = $this->processInformation['exitcode']; } } /* * Closes process resource, closes file handles, sets the exitcode. * * @return Integer The exitcode / private function close() { $this->processPipes->close(); if (is_resource($this->process)) { $exitcode = proc_close($this->process); } else { $exitcode = -1; } $this->exitcode = -1 !== $exitcode ? $exitcode : (null !== $this->exitcode ? $this->exitcode : -1); $this->status = self::STATUS_TERMINATED; if (-1 === $this->exitcode && null !== $this->fallbackExitcode) { $this->exitcode = $this->fallbackExitcode; } elseif (-1 === $this->exitcode && $this->processInformation['signaled'] && 0 < $this->processInformation['termsig']) { // if process has been signaled, no exitcode but a valid termsig, apply Unix convention $this->exitcode = 128 + $this->processInformation['termsig']; } return $this->exitcode; } /* * Resets data related to the latest run of the process. / private function resetProcessData() { $this->starttime = null; $this->callback = null; $this->exitcode = null; $this->fallbackExitcode = null; $this->processInformation = null; $this->stdout = null; $this->stderr = null; $this->process = null; $this->status = self::STATUS_READY; $this->incrementalOutputOffset = 0; $this->incrementalErrorOutputOffset = 0; } /* * Sends a POSIX signal to the process. * * @param integer $signal A valid POSIX signal (see http://www.php.net/manual/en/pcntl.constants.php) * @param Boolean $throwException Whether to throw exception in case signal failed * * @return Boolean True if the signal was sent successfully, false otherwise * * @throws LogicException In case the process is not running * @throws RuntimeException In case --enable-sigchild is activated * @throws RuntimeException In case of failure / private function doSignal($signal, $throwException) { if (!$this->isRunning()) { if ($throwException) { throw new LogicException('Can not send signal on a non running process.'); } return false; } if ($this->isSigchildEnabled()) { if ($throwException) { throw new RuntimeException('This PHP has been compiled with --enable-sigchild. The process can not be signaled.'); } return false; } if (true !== @proc_terminate($this->process, $signal)) { if ($throwException) { throw new RuntimeException(sprintf('Error while sending signal `%s`.', $signal)); } return false; } return true; } /* * Ensures the process is running or terminated, throws a LogicException if the process has a not started. * * @param $functionName The function name that was called. * * @throws LogicException If the process has not run. / private function requireProcessIsStarted($functionName) { if (!$this->isStarted()) { throw new LogicException(sprintf('Process must be started before calling %s.', $functionName)); } } /* * Ensures the process is terminated, throws a LogicException if the process has a status different than `terminated`. * * @param $functionName The function name that was called. * * @throws LogicException If the process is not yet terminated. */ private function requireProcessIsTerminated($functionName) { if (!$this->isTerminated()) { throw new LogicException(sprintf('Process must be terminated before calling %s.', $functionName)); } } }	37.53 KB	2024-07-17 10:22
📄 ProcessBuilder.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Process; use Symfony\Component\Process\Exception\InvalidArgumentException; use Symfony\Component\Process\Exception\LogicException; /* * Process builder. * * @author Kris Wallsmith <kris@symfony.com> / class ProcessBuilder { private $arguments; private $cwd; private $env = array(); private $stdin; private $timeout = 60; private $options = array(); private $inheritEnv = true; private $prefix = array(); public function __construct(array $arguments = array()) { $this->arguments = $arguments; } public static function create(array $arguments = array()) { return new static($arguments); } /* * Adds an unescaped argument to the command string. * * @param string $argument A command argument * * @return ProcessBuilder / public function add($argument) { $this->arguments[] = $argument; return $this; } /* * Adds an unescaped prefix to the command string. * * The prefix is preserved when resetting arguments. * * @param string\|array $prefix A command prefix or an array of command prefixes * * @return ProcessBuilder / public function setPrefix($prefix) { $this->prefix = is_array($prefix) ? $prefix : array($prefix); return $this; } /* * @param array $arguments * * @return ProcessBuilder / public function setArguments(array $arguments) { $this->arguments = $arguments; return $this; } public function setWorkingDirectory($cwd) { $this->cwd = $cwd; return $this; } public function inheritEnvironmentVariables($inheritEnv = true) { $this->inheritEnv = $inheritEnv; return $this; } public function setEnv($name, $value) { $this->env[$name] = $value; return $this; } public function addEnvironmentVariables(array $variables) { $this->env = array_replace($this->env, $variables); return $this; } public function setInput($stdin) { $this->stdin = $stdin; return $this; } /* * Sets the process timeout. * * To disable the timeout, set this value to null. * * @param float\|null * * @return ProcessBuilder * * @throws InvalidArgumentException */ public function setTimeout($timeout) { if (null === $timeout) { $this->timeout = null; return $this; } $timeout = (float) $timeout; if ($timeout < 0) { throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.'); } $this->timeout = $timeout; return $this; } public function setOption($name, $value) { $this->options[$name] = $value; return $this; } public function getProcess() { if (0 === count($this->prefix) && 0 === count($this->arguments)) { throw new LogicException('You must add() command arguments before calling getProcess().'); } $options = $this->options; $arguments = array_merge($this->prefix, $this->arguments); $script = implode(' ', array_map(array(__NAMESPACE__.'\\ProcessUtils', 'escapeArgument'), $arguments)); if ($this->inheritEnv) { // include $_ENV for BC purposes $env = array_replace($_ENV, $_SERVER, $this->env); } else { $env = $this->env; } return new Process($script, $this->cwd, $env, $this->stdin, $this->timeout, $options); } }	3.88 KB	2024-07-17 10:22
📄 ProcessPipes.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Process; use Symfony\Component\Process\Exception\RuntimeException; /* * ProcessPipes manages descriptors and pipes for the use of proc_open. / class ProcessPipes { /* @var array / public $pipes = array(); /* @var array / private $files = array(); /* @var array / private $fileHandles = array(); /* @var array / private $readBytes = array(); /* @var Boolean / private $useFiles; /* @var Boolean / private $ttyMode; const CHUNK_SIZE = 16384; public function __construct($useFiles, $ttyMode) { $this->useFiles = (Boolean) $useFiles; $this->ttyMode = (Boolean) $ttyMode; // Fix for PHP bug #51800: reading from STDOUT pipe hangs forever on Windows if the output is too big. // Workaround for this problem is to use temporary files instead of pipes on Windows platform. // // @see https://bugs.php.net/bug.php?id=51800 if ($this->useFiles) { $this->files = array( Process::STDOUT => tempnam(sys_get_temp_dir(), 'sf_proc_stdout'), Process::STDERR => tempnam(sys_get_temp_dir(), 'sf_proc_stderr'), ); foreach ($this->files as $offset => $file) { $this->fileHandles[$offset] = fopen($this->files[$offset], 'rb'); if (false === $this->fileHandles[$offset]) { throw new RuntimeException('A temporary file could not be opened to write the process output to, verify that your TEMP environment variable is writable'); } } $this->readBytes = array( Process::STDOUT => 0, Process::STDERR => 0, ); } } public function __destruct() { $this->close(); $this->removeFiles(); } /* * Sets non-blocking mode on pipes. / public function unblock() { foreach ($this->pipes as $pipe) { stream_set_blocking($pipe, 0); } } /* * Closes file handles and pipes. / public function close() { $this->closeUnixPipes(); foreach ($this->fileHandles as $handle) { fclose($handle); } $this->fileHandles = array(); } /* * Closes Unix pipes. * * Nothing happens in case file handles are used. / public function closeUnixPipes() { foreach ($this->pipes as $pipe) { fclose($pipe); } $this->pipes = array(); } /* * Returns an array of descriptors for the use of proc_open. * * @return array / public function getDescriptors() { if ($this->useFiles) { // We're not using pipe on Windows platform as it hangs (https://bugs.php.net/bug.php?id=51800) // We're not using file handles as it can produce corrupted output https://bugs.php.net/bug.php?id=65650 // So we redirect output within the commandline and pass the nul device to the process return array( array('pipe', 'r'), array('file', 'NUL', 'w'), array('file', 'NUL', 'w'), ); } if ($this->ttyMode) { return array( array('file', '/dev/tty', 'r'), array('file', '/dev/tty', 'w'), array('file', '/dev/tty', 'w'), ); } return array( array('pipe', 'r'), // stdin array('pipe', 'w'), // stdout array('pipe', 'w'), // stderr ); } /* * Returns an array of filenames indexed by their related stream in case these pipes use temporary files. * * @return array / public function getFiles() { if ($this->useFiles) { return $this->files; } return array(); } /* * Reads data in file handles and pipes. * * @param Boolean $blocking Whether to use blocking calls or not. * * @return array An array of read data indexed by their fd. / public function read($blocking) { return array_replace($this->readStreams($blocking), $this->readFileHandles()); } /* * Reads data in file handles and pipes, closes them if EOF is reached. * * @param Boolean $blocking Whether to use blocking calls or not. * * @return array An array of read data indexed by their fd. / public function readAndCloseHandles($blocking) { return array_replace($this->readStreams($blocking, true), $this->readFileHandles(true)); } /* * Returns if the current state has open file handles or pipes. * * @return Boolean / public function hasOpenHandles() { if (!$this->useFiles) { return (Boolean) $this->pipes; } return (Boolean) $this->pipes && (Boolean) $this->fileHandles; } /* * Writes stdin data. * * @param Boolean $blocking Whether to use blocking calls or not. * @param string\|null $stdin The data to write. / public function write($blocking, $stdin) { if (null === $stdin) { fclose($this->pipes[0]); unset($this->pipes[0]); return; } $writePipes = array($this->pipes[0]); unset($this->pipes[0]); $stdinLen = strlen($stdin); $stdinOffset = 0; while ($writePipes) { $r = null; $w = $writePipes; $e = null; if (false === $n = @stream_select($r, $w, $e, 0, $blocking ? ceil(Process::TIMEOUT_PRECISION 1E6) : 0)) { // if a system call has been interrupted, forget about it, let's try again if ($this->hasSystemCallBeenInterrupted()) { continue; } break; } // nothing has changed, let's wait until the process is ready if (0 === $n) { continue; } if ($w) { $written = fwrite($writePipes[0], (binary) substr($stdin, $stdinOffset), 8192); if (false !== $written) { $stdinOffset += $written; } if ($stdinOffset >= $stdinLen) { fclose($writePipes[0]); $writePipes = null; } } } } /** * Reads data in file handles. * * @param Boolean $close Whether to close file handles or not. * * @return array An array of read data indexed by their fd. / private function readFileHandles($close = false) { $read = array(); $fh = $this->fileHandles; foreach ($fh as $type => $fileHandle) { if (0 !== fseek($fileHandle, $this->readBytes[$type])) { continue; } $data = ''; $dataread = null; while (!feof($fileHandle)) { if (false !== $dataread = fread($fileHandle, self::CHUNK_SIZE)) { $data .= $dataread; } } if (0 < $length = strlen($data)) { $this->readBytes[$type] += $length; $read[$type] = $data; } if (false === $dataread \|\| (true === $close && feof($fileHandle) && '' === $data)) { fclose($this->fileHandles[$type]); unset($this->fileHandles[$type]); } } return $read; } /* * Reads data in file pipes streams. * * @param Boolean $blocking Whether to use blocking calls or not. * @param Boolean $close Whether to close file handles or not. * * @return array An array of read data indexed by their fd. / private function readStreams($blocking, $close = false) { if (empty($this->pipes)) { return array(); } $read = array(); $r = $this->pipes; $w = null; $e = null; // let's have a look if something changed in streams if (false === $n = @stream_select($r, $w, $e, 0, $blocking ? ceil(Process::TIMEOUT_PRECISION 1E6) : 0)) { // if a system call has been interrupted, forget about it, let's try again // otherwise, an error occurred, let's reset pipes if (!$this->hasSystemCallBeenInterrupted()) { $this->pipes = array(); } return $read; } // nothing has changed if (0 === $n) { return $read; } foreach ($r as $pipe) { $type = array_search($pipe, $this->pipes); $data = ''; while ($dataread = fread($pipe, self::CHUNK_SIZE)) { $data .= $dataread; } if ($data) { $read[$type] = $data; } if (false === $data \|\| (true === $close && feof($pipe) && '' === $data)) { fclose($this->pipes[$type]); unset($this->pipes[$type]); } } return $read; } /** * Returns true if a system call has been interrupted. * * @return Boolean / private function hasSystemCallBeenInterrupted() { $lastError = error_get_last(); // stream_select returns false when the `select` system call is interrupted by an incoming signal return isset($lastError['message']) && false !== stripos($lastError['message'], 'interrupted system call'); } /* * Removes temporary files */ private function removeFiles() { foreach ($this->files as $filename) { if (file_exists($filename)) { @unlink($filename); } } $this->files = array(); } }	9.98 KB	2024-07-17 10:22
📄 ProcessUtils.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Process; /* * ProcessUtils is a bunch of utility methods. * * This class contains static methods only and is not meant to be instantiated. * * @author Martin Hasoň <martin.hason@gmail.com> / class ProcessUtils { /* * This class should not be instantiated / private function __construct() { } /* * Escapes a string to be used as a shell argument. * * @param string $argument The argument that will be escaped * * @return string The escaped argument */ public static function escapeArgument($argument) { //Fix for PHP bug #43784 escapeshellarg removes % from given string //Fix for PHP bug #49446 escapeshellarg doesn't work on Windows //@see https://bugs.php.net/bug.php?id=43784 //@see https://bugs.php.net/bug.php?id=49446 if (defined('PHP_WINDOWS_VERSION_BUILD')) { if ('' === $argument) { return escapeshellarg($argument); } $escapedArgument = ''; $quote = false; foreach (preg_split('/(")/i', $argument, -1, PREG_SPLIT_NO_EMPTY \| PREG_SPLIT_DELIM_CAPTURE) as $part) { if ('"' === $part) { $escapedArgument .= '\\"'; } elseif (self::isSurroundedBy($part, '%')) { // Avoid environment variable expansion $escapedArgument .= '^%"'.substr($part, 1, -1).'"^%'; } else { // escape trailing backslash if ('\\' === substr($part, -1)) { $part .= '\\'; } $quote = true; $escapedArgument .= $part; } } if ($quote) { $escapedArgument = '"'.$escapedArgument.'"'; } return $escapedArgument; } return escapeshellarg($argument); } private static function isSurroundedBy($arg, $char) { return 2 < strlen($arg) && $char === $arg[0] && $char === $arg[strlen($arg) - 1]; } }	2.32 KB	2024-07-17 10:22
📄 autoloader.php <?php spl_autoload_register(function ($class) { if ('\\' == $class[0]) { $class = substr($class, 1); } if ( 0 === strpos($class, 'Symfony\\Component\\Process\\') && file_exists($file = __DIR__.'/../../../'.str_replace('\\', '/', $class).'.php') ) { require_once $file; } });	337 B	2024-07-17 10:22

Terminal