vendor/symfony/process/Process.php line 147

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Process;
  14. use Symfony\Component\Process\Exception\InvalidArgumentException;
  15. use Symfony\Component\Process\Exception\LogicException;
  16. use Symfony\Component\Process\Exception\ProcessFailedException;
  17. use Symfony\Component\Process\Exception\ProcessSignaledException;
  18. use Symfony\Component\Process\Exception\ProcessTimedOutException;
  19. use Symfony\Component\Process\Exception\RuntimeException;
  20. use Symfony\Component\Process\Pipes\PipesInterface;
  21. use Symfony\Component\Process\Pipes\UnixPipes;
  22. use Symfony\Component\Process\Pipes\WindowsPipes;
  24. /**
  25.  * Process is a thin wrapper around proc_* functions to easily
  26.  * start independent PHP processes.
  27.  *
  28.  * @author Fabien Potencier <fabien@symfony.com>
  29.  * @author Romain Neutron <imprec@gmail.com>
  30.  */
  31. class Process implements \IteratorAggregate
  32. {
  33.     const ERR = 'err';
  34.     const OUT = 'out';
  36.     const STATUS_READY = 'ready';
  37.     const STATUS_STARTED = 'started';
  38.     const STATUS_TERMINATED = 'terminated';
  40.     const STDIN = 0;
  41.     const STDOUT = 1;
  42.     const STDERR = 2;
  44.     // Timeout Precision in seconds.
  45.     const TIMEOUT_PRECISION = 0.2;
  47.     const ITER_NON_BLOCKING = 1; // By default, iterating over outputs is a blocking call, use this flag to make it non-blocking
  48.     const ITER_KEEP_OUTPUT = 2;  // By default, outputs are cleared while iterating, use this flag to keep them in memory
  49.     const ITER_SKIP_OUT = 4;     // Use this flag to skip STDOUT while iterating
  50.     const ITER_SKIP_ERR = 8;     // Use this flag to skip STDERR while iterating
  52.     private $callback;
  53.     private $hasCallback = false;
  54.     private $commandline;
  55.     private $cwd;
  56.     private $env;
  57.     private $input;
  58.     private $starttime;
  59.     private $lastOutputTime;
  60.     private $timeout;
  61.     private $idleTimeout;
  62.     private $exitcode;
  63.     private $fallbackStatus = [];
  64.     private $processInformation;
  65.     private $outputDisabled = false;
  66.     private $stdout;
  67.     private $stderr;
  68.     private $process;
  69.     private $status = self::STATUS_READY;
  70.     private $incrementalOutputOffset = 0;
  71.     private $incrementalErrorOutputOffset = 0;
  72.     private $tty = false;
  73.     private $pty;
  75.     private $useFileHandles = false;
  76.     /** @var PipesInterface */
  77.     private $processPipes;
  79.     private $latestSignal;
  81.     private static $sigchild;
  83.     /**
  84.      * Exit codes translation table.
  85.      *
  86.      * User-defined errors must use exit codes in the 64-113 range.
  87.      */
  88.     public static $exitCodes = [
  89.         0 => 'OK',
  90.         1 => 'General error',
  91.         2 => 'Misuse of shell builtins',
  93.         126 => 'Invoked command cannot execute',
  94.         127 => 'Command not found',
  95.         128 => 'Invalid exit argument',
  97.         // signals
  98.         129 => 'Hangup',
  99.         130 => 'Interrupt',
  100.         131 => 'Quit and dump core',
  101.         132 => 'Illegal instruction',
  102.         133 => 'Trace/breakpoint trap',
  103.         134 => 'Process aborted',
  104.         135 => 'Bus error: "access to undefined portion of memory object"',
  105.         136 => 'Floating point exception: "erroneous arithmetic operation"',
  106.         137 => 'Kill (terminate immediately)',
  107.         138 => 'User-defined 1',
  108.         139 => 'Segmentation violation',
  109.         140 => 'User-defined 2',
  110.         141 => 'Write to pipe with no one reading',
  111.         142 => 'Signal raised by alarm',
  112.         143 => 'Termination (request to terminate)',
  113.         // 144 - not defined
  114.         145 => 'Child process terminated, stopped (or continued*)',
  115.         146 => 'Continue if stopped',
  116.         147 => 'Stop executing temporarily',
  117.         148 => 'Terminal stop signal',
  118.         149 => 'Background process attempting to read from tty ("in")',
  119.         150 => 'Background process attempting to write to tty ("out")',
  120.         151 => 'Urgent data available on socket',
  121.         152 => 'CPU time limit exceeded',
  122.         153 => 'File size limit exceeded',
  123.         154 => 'Signal raised by timer counting virtual time: "virtual timer expired"',
  124.         155 => 'Profiling timer expired',
  125.         // 156 - not defined
  126.         157 => 'Pollable event',
  127.         // 158 - not defined
  128.         159 => 'Bad syscall',
  129.     ];
  131.     /**
  132.      * @param array          $command The command to run and its arguments listed as separate entries
  133.      * @param string|null    $cwd     The working directory or null to use the working dir of the current PHP process
  134.      * @param array|null     $env     The environment variables or null to use the same environment as the current PHP process
  135.      * @param mixed|null     $input   The input as stream resource, scalar or \Traversable, or null for no input
  136.      * @param int|float|null $timeout The timeout in seconds or null to disable
  137.      *
  138.      * @throws LogicException When proc_open is not installed
  139.      */
  140.     public function __construct($command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
  141.     {
  142.         if (!\function_exists('proc_open')) {
  143.             throw new LogicException('The Process class relies on proc_open, which is not available on your PHP installation.');
  144.         }
  146.         if (!\is_array($command)) {
  147.             @trigger_error(sprintf('Passing a command as string when creating a "%s" instance is deprecated since Symfony 4.2, pass it as an array of its arguments instead, or use the "Process::fromShellCommandline()" constructor if you need features provided by the shell.', __CLASS__), \E_USER_DEPRECATED);
  148.         }
  150.         $this->commandline = $command;
  151.         $this->cwd = $cwd;
  153.         // on Windows, if the cwd changed via chdir(), proc_open defaults to the dir where PHP was started
  154.         // on Gnu/Linux, PHP builds with --enable-maintainer-zts are also affected
  155.         // @see : https://bugs.php.net/51800
  156.         // @see : https://bugs.php.net/50524
  157.         if (null === $this->cwd && (\defined('ZEND_THREAD_SAFE') || '\\' === \DIRECTORY_SEPARATOR)) {
  158.             $this->cwd = getcwd();
  159.         }
  160.         if (null !== $env) {
  161.             $this->setEnv($env);
  162.         }
  164.         $this->setInput($input);
  165.         $this->setTimeout($timeout);
  166.         $this->useFileHandles = '\\' === \DIRECTORY_SEPARATOR;
  167.         $this->pty = false;
  168.     }
  170.     /**
  171.      * Creates a Process instance as a command-line to be run in a shell wrapper.
  172.      *
  173.      * Command-lines are parsed by the shell of your OS (/bin/sh on Unix-like, cmd.exe on Windows.)
  174.      * This allows using e.g. pipes or conditional execution. In this mode, signals are sent to the
  175.      * shell wrapper and not to your commands.
  176.      *
  177.      * In order to inject dynamic values into command-lines, we strongly recommend using placeholders.
  178.      * This will save escaping values, which is not portable nor secure anyway:
  179.      *
  180.      *   $process = Process::fromShellCommandline('my_command "$MY_VAR"');
  181.      *   $process->run(null, ['MY_VAR' => $theValue]);
  182.      *
  183.      * @param string         $command The command line to pass to the shell of the OS
  184.      * @param string|null    $cwd     The working directory or null to use the working dir of the current PHP process
  185.      * @param array|null     $env     The environment variables or null to use the same environment as the current PHP process
  186.      * @param mixed|null     $input   The input as stream resource, scalar or \Traversable, or null for no input
  187.      * @param int|float|null $timeout The timeout in seconds or null to disable
  188.      *
  189.      * @return static
  190.      *
  191.      * @throws LogicException When proc_open is not installed
  192.      */
  193.     public static function fromShellCommandline(string $command, string $cwd = null, array $env = null, $input = null, ?float $timeout = 60)
  194.     {
  195.         $process = new static([], $cwd, $env, $input, $timeout);
  196.         $process->commandline = $command;
  198.         return $process;
  199.     }
  201.     public function __destruct()
  202.     {
  203.         $this->stop(0);
  204.     }
  206.     public function __clone()
  207.     {
  208.         $this->resetProcessData();
  209.     }
  211.     /**
  212.      * Runs the process.
  213.      *
  214.      * The callback receives the type of output (out or err) and
  215.      * some bytes from the output in real-time. It allows to have feedback
  216.      * from the independent process during execution.
  217.      *
  218.      * The STDOUT and STDERR are also available after the process is finished
  219.      * via the getOutput() and getErrorOutput() methods.
  220.      *
  221.      * @param callable|null $callback A PHP callback to run whenever there is some
  222.      *                                output available on STDOUT or STDERR
  223.      *
  224.      * @return int The exit status code
  225.      *
  226.      * @throws RuntimeException         When process can't be launched
  227.      * @throws RuntimeException         When process is already running
  228.      * @throws ProcessTimedOutException When process timed out
  229.      * @throws ProcessSignaledException When process stopped after receiving signal
  230.      * @throws LogicException           In case a callback is provided and output has been disabled
  231.      *
  232.      * @final
  233.      */
  234.     public function run(callable $callback = null, array $env = []): int
  235.     {
  236.         $this->start($callback, $env);
  238.         return $this->wait();
  239.     }
  241.     /**
  242.      * Runs the process.
  243.      *
  244.      * This is identical to run() except that an exception is thrown if the process
  245.      * exits with a non-zero exit code.
  246.      *
  247.      * @return $this
  248.      *
  249.      * @throws ProcessFailedException if the process didn't terminate successfully
  250.      *
  251.      * @final
  252.      */
  253.     public function mustRun(callable $callback = null, array $env = []): self
  254.     {
  255.         if (0 !== $this->run($callback, $env)) {
  256.             throw new ProcessFailedException($this);
  257.         }
  259.         return $this;
  260.     }
  262.     /**
  263.      * Starts the process and returns after writing the input to STDIN.
  264.      *
  265.      * This method blocks until all STDIN data is sent to the process then it
  266.      * returns while the process runs in the background.
  267.      *
  268.      * The termination of the process can be awaited with wait().
  269.      *
  270.      * The callback receives the type of output (out or err) and some bytes from
  271.      * the output in real-time while writing the standard input to the process.
  272.      * It allows to have feedback from the independent process during execution.
  273.      *
  274.      * @param callable|null $callback A PHP callback to run whenever there is some
  275.      *                                output available on STDOUT or STDERR
  276.      *
  277.      * @throws RuntimeException When process can't be launched
  278.      * @throws RuntimeException When process is already running
  279.      * @throws LogicException   In case a callback is provided and output has been disabled
  280.      */
  281.     public function start(callable $callback = null, array $env = [])
  282.     {
  283.         if ($this->isRunning()) {
  284.             throw new RuntimeException('Process is already running.');
  285.         }
  287.         $this->resetProcessData();
  288.         $this->starttime = $this->lastOutputTime = microtime(true);
  289.         $this->callback = $this->buildCallback($callback);
  290.         $this->hasCallback = null !== $callback;
  291.         $descriptors = $this->getDescriptors();
  293.         if ($this->env) {
  294.             $env += $this->env;
  295.         }
  297.         $env += $this->getDefaultEnv();
  299.         if (\is_array($commandline = $this->commandline)) {
  300.             $commandline = implode(' ', array_map([$this, 'escapeArgument'], $commandline));
  302.             if ('\\' !== \DIRECTORY_SEPARATOR) {
  303.                 // exec is mandatory to deal with sending a signal to the process
  304.                 $commandline = 'exec '.$commandline;
  305.             }
  306.         } else {
  307.             $commandline = $this->replacePlaceholders($commandline, $env);
  308.         }
  310.         $options = ['suppress_errors' => true];
  312.         if ('\\' === \DIRECTORY_SEPARATOR) {
  313.             $options['bypass_shell'] = true;
  314.             $commandline = $this->prepareWindowsCommandLine($commandline, $env);
  315.         } elseif (!$this->useFileHandles && $this->isSigchildEnabled()) {
  316.             // last exit code is output on the fourth pipe and caught to work around --enable-sigchild
  317.             $descriptors[3] = ['pipe', 'w'];
  319.             // See https://unix.stackexchange.com/questions/71205/background-process-pipe-input
  320.             $commandline = '{ ('.$commandline.') <&3 3<&- 3>/dev/null & } 3<&0;';
  321.             $commandline .= 'pid=$!; echo $pid >&3; wait $pid; code=$?; echo $code >&3; exit $code';
  323.             // Workaround for the bug, when PTS functionality is enabled.
  324.             // @see : https://bugs.php.net/69442
  325.             $ptsWorkaround = fopen(__FILE__, 'r');
  326.         }
  328.         $envPairs = [];
  329.         foreach ($env as $k => $v) {
  330.             if (false !== $v) {
  331.                 $envPairs[] = $k.'='.$v;
  332.             }
  333.         }
  335.         if (!is_dir($this->cwd)) {
  336.             throw new RuntimeException(sprintf('The provided cwd "%s" does not exist.', $this->cwd));
  337.         }
  339.         $this->process = @proc_open($commandline, $descriptors, $this->processPipes->pipes, $this->cwd, $envPairs, $options);
  341.         if (!\is_resource($this->process)) {
  342.             throw new RuntimeException('Unable to launch a new process.');
  343.         }
  344.         $this->status = self::STATUS_STARTED;
  346.         if (isset($descriptors[3])) {
  347.             $this->fallbackStatus['pid'] = (int) fgets($this->processPipes->pipes[3]);
  348.         }
  350.         if ($this->tty) {
  351.             return;
  352.         }
  354.         $this->updateStatus(false);
  355.         $this->checkTimeout();
  356.     }
  358.     /**
  359.      * Restarts the process.
  360.      *
  361.      * Be warned that the process is cloned before being started.
  362.      *
  363.      * @param callable|null $callback A PHP callback to run whenever there is some
  364.      *                                output available on STDOUT or STDERR
  365.      *
  366.      * @return static
  367.      *
  368.      * @throws RuntimeException When process can't be launched
  369.      * @throws RuntimeException When process is already running
  370.      *
  371.      * @see start()
  372.      *
  373.      * @final
  374.      */
  375.     public function restart(callable $callback = null, array $env = []): self
  376.     {
  377.         if ($this->isRunning()) {
  378.             throw new RuntimeException('Process is already running.');
  379.         }
  381.         $process = clone $this;
  382.         $process->start($callback, $env);
  384.         return $process;
  385.     }
  387.     /**
  388.      * Waits for the process to terminate.
  389.      *
  390.      * The callback receives the type of output (out or err) and some bytes
  391.      * from the output in real-time while writing the standard input to the process.
  392.      * It allows to have feedback from the independent process during execution.
  393.      *
  394.      * @param callable|null $callback A valid PHP callback
  395.      *
  396.      * @return int The exitcode of the process
  397.      *
  398.      * @throws ProcessTimedOutException When process timed out
  399.      * @throws ProcessSignaledException When process stopped after receiving signal
  400.      * @throws LogicException           When process is not yet started
  401.      */
  402.     public function wait(callable $callback = null)
  403.     {
  404.         $this->requireProcessIsStarted(__FUNCTION__);
  406.         $this->updateStatus(false);
  408.         if (null !== $callback) {
  409.             if (!$this->processPipes->haveReadSupport()) {
  410.                 $this->stop(0);
  411.                 throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::wait".');
  412.             }
  413.             $this->callback = $this->buildCallback($callback);
  414.         }
  416.         do {
  417.             $this->checkTimeout();
  418.             $running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
  419.             $this->readPipes($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
  420.         } while ($running);
  422.         while ($this->isRunning()) {
  423.             $this->checkTimeout();
  424.             usleep(1000);
  425.         }
  427.         if ($this->processInformation['signaled'] && $this->processInformation['termsig'] !== $this->latestSignal) {
  428.             throw new ProcessSignaledException($this);
  429.         }
  431.         return $this->exitcode;
  432.     }
  434.     /**
  435.      * Waits until the callback returns true.
  436.      *
  437.      * The callback receives the type of output (out or err) and some bytes
  438.      * from the output in real-time while writing the standard input to the process.
  439.      * It allows to have feedback from the independent process during execution.
  440.      *
  441.      * @throws RuntimeException         When process timed out
  442.      * @throws LogicException           When process is not yet started
  443.      * @throws ProcessTimedOutException In case the timeout was reached
  444.      */
  445.     public function waitUntil(callable $callback): bool
  446.     {
  447.         $this->requireProcessIsStarted(__FUNCTION__);
  448.         $this->updateStatus(false);
  450.         if (!$this->processPipes->haveReadSupport()) {
  451.             $this->stop(0);
  452.             throw new LogicException('Pass the callback to the "Process::start" method or call enableOutput to use a callback with "Process::waitUntil".');
  453.         }
  454.         $callback = $this->buildCallback($callback);
  456.         $ready = false;
  457.         while (true) {
  458.             $this->checkTimeout();
  459.             $running = '\\' === \DIRECTORY_SEPARATOR ? $this->isRunning() : $this->processPipes->areOpen();
  460.             $output = $this->processPipes->readAndWrite($running, '\\' !== \DIRECTORY_SEPARATOR || !$running);
  462.             foreach ($output as $type => $data) {
  463.                 if (3 !== $type) {
  464.                     $ready = $callback(self::STDOUT === $type ? self::OUT : self::ERR, $data) || $ready;
  465.                 } elseif (!isset($this->fallbackStatus['signaled'])) {
  466.                     $this->fallbackStatus['exitcode'] = (int) $data;
  467.                 }
  468.             }
  469.             if ($ready) {
  470.                 return true;
  471.             }
  472.             if (!$running) {
  473.                 return false;
  474.             }
  476.             usleep(1000);
  477.         }
  478.     }
  480.     /**
  481.      * Returns the Pid (process identifier), if applicable.
  482.      *
  483.      * @return int|null The process id if running, null otherwise
  484.      */
  485.     public function getPid()
  486.     {
  487.         return $this->isRunning() ? $this->processInformation['pid'] : null;
  488.     }
  490.     /**
  491.      * Sends a POSIX signal to the process.
  492.      *
  493.      * @param int $signal A valid POSIX signal (see https://php.net/pcntl.constants)
  494.      *
  495.      * @return $this
  496.      *
  497.      * @throws LogicException   In case the process is not running
  498.      * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
  499.      * @throws RuntimeException In case of failure
  500.      */
  501.     public function signal($signal)
  502.     {
  503.         $this->doSignal($signal, true);
  505.         return $this;
  506.     }
  508.     /**
  509.      * Disables fetching output and error output from the underlying process.
  510.      *
  511.      * @return $this
  512.      *
  513.      * @throws RuntimeException In case the process is already running
  514.      * @throws LogicException   if an idle timeout is set
  515.      */
  516.     public function disableOutput()
  517.     {
  518.         if ($this->isRunning()) {
  519.             throw new RuntimeException('Disabling output while the process is running is not possible.');
  520.         }
  521.         if (null !== $this->idleTimeout) {
  522.             throw new LogicException('Output can not be disabled while an idle timeout is set.');
  523.         }
  525.         $this->outputDisabled = true;
  527.         return $this;
  528.     }
  530.     /**
  531.      * Enables fetching output and error output from the underlying process.
  532.      *
  533.      * @return $this
  534.      *
  535.      * @throws RuntimeException In case the process is already running
  536.      */
  537.     public function enableOutput()
  538.     {
  539.         if ($this->isRunning()) {
  540.             throw new RuntimeException('Enabling output while the process is running is not possible.');
  541.         }
  543.         $this->outputDisabled = false;
  545.         return $this;
  546.     }
  548.     /**
  549.      * Returns true in case the output is disabled, false otherwise.
  550.      *
  551.      * @return bool
  552.      */
  553.     public function isOutputDisabled()
  554.     {
  555.         return $this->outputDisabled;
  556.     }
  558.     /**
  559.      * Returns the current output of the process (STDOUT).
  560.      *
  561.      * @return string The process output
  562.      *
  563.      * @throws LogicException in case the output has been disabled
  564.      * @throws LogicException In case the process is not started
  565.      */
  566.     public function getOutput()
  567.     {
  568.         $this->readPipesForOutput(__FUNCTION__);
  570.         if (false === $ret = stream_get_contents($this->stdout, -1, 0)) {
  571.             return '';
  572.         }
  574.         return $ret;
  575.     }
  577.     /**
  578.      * Returns the output incrementally.
  579.      *
  580.      * In comparison with the getOutput method which always return the whole
  581.      * output, this one returns the new output since the last call.
  582.      *
  583.      * @return string The process output since the last call
  584.      *
  585.      * @throws LogicException in case the output has been disabled
  586.      * @throws LogicException In case the process is not started
  587.      */
  588.     public function getIncrementalOutput()
  589.     {
  590.         $this->readPipesForOutput(__FUNCTION__);
  592.         $latest = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
  593.         $this->incrementalOutputOffset = ftell($this->stdout);
  595.         if (false === $latest) {
  596.             return '';
  597.         }
  599.         return $latest;
  600.     }
  602.     /**
  603.      * Returns an iterator to the output of the process, with the output type as keys (Process::OUT/ERR).
  604.      *
  605.      * @param int $flags A bit field of Process::ITER_* flags
  606.      *
  607.      * @throws LogicException in case the output has been disabled
  608.      * @throws LogicException In case the process is not started
  609.      *
  610.      * @return \Generator
  611.      */
  612.     public function getIterator($flags = 0)
  613.     {
  614.         $this->readPipesForOutput(__FUNCTION__, false);
  616.         $clearOutput = !(self::ITER_KEEP_OUTPUT & $flags);
  617.         $blocking = !(self::ITER_NON_BLOCKING & $flags);
  618.         $yieldOut = !(self::ITER_SKIP_OUT & $flags);
  619.         $yieldErr = !(self::ITER_SKIP_ERR & $flags);
  621.         while (null !== $this->callback || ($yieldOut && !feof($this->stdout)) || ($yieldErr && !feof($this->stderr))) {
  622.             if ($yieldOut) {
  623.                 $out = stream_get_contents($this->stdout, -1, $this->incrementalOutputOffset);
  625.                 if (isset($out[0])) {
  626.                     if ($clearOutput) {
  627.                         $this->clearOutput();
  628.                     } else {
  629.                         $this->incrementalOutputOffset = ftell($this->stdout);
  630.                     }
  632.                     yield self::OUT => $out;
  633.                 }
  634.             }
  636.             if ($yieldErr) {
  637.                 $err = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
  639.                 if (isset($err[0])) {
  640.                     if ($clearOutput) {
  641.                         $this->clearErrorOutput();
  642.                     } else {
  643.                         $this->incrementalErrorOutputOffset = ftell($this->stderr);
  644.                     }
  646.                     yield self::ERR => $err;
  647.                 }
  648.             }
  650.             if (!$blocking && !isset($out[0]) && !isset($err[0])) {
  651.                 yield self::OUT => '';
  652.             }
  654.             $this->checkTimeout();
  655.             $this->readPipesForOutput(__FUNCTION__, $blocking);
  656.         }
  657.     }
  659.     /**
  660.      * Clears the process output.
  661.      *
  662.      * @return $this
  663.      */
  664.     public function clearOutput()
  665.     {
  666.         ftruncate($this->stdout, 0);
  667.         fseek($this->stdout, 0);
  668.         $this->incrementalOutputOffset = 0;
  670.         return $this;
  671.     }
  673.     /**
  674.      * Returns the current error output of the process (STDERR).
  675.      *
  676.      * @return string The process error output
  677.      *
  678.      * @throws LogicException in case the output has been disabled
  679.      * @throws LogicException In case the process is not started
  680.      */
  681.     public function getErrorOutput()
  682.     {
  683.         $this->readPipesForOutput(__FUNCTION__);
  685.         if (false === $ret = stream_get_contents($this->stderr, -1, 0)) {
  686.             return '';
  687.         }
  689.         return $ret;
  690.     }
  692.     /**
  693.      * Returns the errorOutput incrementally.
  694.      *
  695.      * In comparison with the getErrorOutput method which always return the
  696.      * whole error output, this one returns the new error output since the last
  697.      * call.
  698.      *
  699.      * @return string The process error output since the last call
  700.      *
  701.      * @throws LogicException in case the output has been disabled
  702.      * @throws LogicException In case the process is not started
  703.      */
  704.     public function getIncrementalErrorOutput()
  705.     {
  706.         $this->readPipesForOutput(__FUNCTION__);
  708.         $latest = stream_get_contents($this->stderr, -1, $this->incrementalErrorOutputOffset);
  709.         $this->incrementalErrorOutputOffset = ftell($this->stderr);
  711.         if (false === $latest) {
  712.             return '';
  713.         }
  715.         return $latest;
  716.     }
  718.     /**
  719.      * Clears the process output.
  720.      *
  721.      * @return $this
  722.      */
  723.     public function clearErrorOutput()
  724.     {
  725.         ftruncate($this->stderr, 0);
  726.         fseek($this->stderr, 0);
  727.         $this->incrementalErrorOutputOffset = 0;
  729.         return $this;
  730.     }
  732.     /**
  733.      * Returns the exit code returned by the process.
  734.      *
  735.      * @return int|null The exit status code, null if the Process is not terminated
  736.      */
  737.     public function getExitCode()
  738.     {
  739.         $this->updateStatus(false);
  741.         return $this->exitcode;
  742.     }
  744.     /**
  745.      * Returns a string representation for the exit code returned by the process.
  746.      *
  747.      * This method relies on the Unix exit code status standardization
  748.      * and might not be relevant for other operating systems.
  749.      *
  750.      * @return string|null A string representation for the exit status code, null if the Process is not terminated
  751.      *
  752.      * @see http://tldp.org/LDP/abs/html/exitcodes.html
  753.      * @see http://en.wikipedia.org/wiki/Unix_signal
  754.      */
  755.     public function getExitCodeText()
  756.     {
  757.         if (null === $exitcode = $this->getExitCode()) {
  758.             return null;
  759.         }
  761.         return isset(self::$exitCodes[$exitcode]) ? self::$exitCodes[$exitcode] : 'Unknown error';
  762.     }
  764.     /**
  765.      * Checks if the process ended successfully.
  766.      *
  767.      * @return bool true if the process ended successfully, false otherwise
  768.      */
  769.     public function isSuccessful()
  770.     {
  771.         return 0 === $this->getExitCode();
  772.     }
  774.     /**
  775.      * Returns true if the child process has been terminated by an uncaught signal.
  776.      *
  777.      * It always returns false on Windows.
  778.      *
  779.      * @return bool
  780.      *
  781.      * @throws LogicException In case the process is not terminated
  782.      */
  783.     public function hasBeenSignaled()
  784.     {
  785.         $this->requireProcessIsTerminated(__FUNCTION__);
  787.         return $this->processInformation['signaled'];
  788.     }
  790.     /**
  791.      * Returns the number of the signal that caused the child process to terminate its execution.
  792.      *
  793.      * It is only meaningful if hasBeenSignaled() returns true.
  794.      *
  795.      * @return int
  796.      *
  797.      * @throws RuntimeException In case --enable-sigchild is activated
  798.      * @throws LogicException   In case the process is not terminated
  799.      */
  800.     public function getTermSignal()
  801.     {
  802.         $this->requireProcessIsTerminated(__FUNCTION__);
  804.         if ($this->isSigchildEnabled() && -1 === $this->processInformation['termsig']) {
  805.             throw new RuntimeException('This PHP has been compiled with --enable-sigchild. Term signal can not be retrieved.');
  806.         }
  808.         return $this->processInformation['termsig'];
  809.     }
  811.     /**
  812.      * Returns true if the child process has been stopped by a signal.
  813.      *
  814.      * It always returns false on Windows.
  815.      *
  816.      * @return bool
  817.      *
  818.      * @throws LogicException In case the process is not terminated
  819.      */
  820.     public function hasBeenStopped()
  821.     {
  822.         $this->requireProcessIsTerminated(__FUNCTION__);
  824.         return $this->processInformation['stopped'];
  825.     }
  827.     /**
  828.      * Returns the number of the signal that caused the child process to stop its execution.
  829.      *
  830.      * It is only meaningful if hasBeenStopped() returns true.
  831.      *
  832.      * @return int
  833.      *
  834.      * @throws LogicException In case the process is not terminated
  835.      */
  836.     public function getStopSignal()
  837.     {
  838.         $this->requireProcessIsTerminated(__FUNCTION__);
  840.         return $this->processInformation['stopsig'];
  841.     }
  843.     /**
  844.      * Checks if the process is currently running.
  845.      *
  846.      * @return bool true if the process is currently running, false otherwise
  847.      */
  848.     public function isRunning()
  849.     {
  850.         if (self::STATUS_STARTED !== $this->status) {
  851.             return false;
  852.         }
  854.         $this->updateStatus(false);
  856.         return $this->processInformation['running'];
  857.     }
  859.     /**
  860.      * Checks if the process has been started with no regard to the current state.
  861.      *
  862.      * @return bool true if status is ready, false otherwise
  863.      */
  864.     public function isStarted()
  865.     {
  866.         return self::STATUS_READY != $this->status;
  867.     }
  869.     /**
  870.      * Checks if the process is terminated.
  871.      *
  872.      * @return bool true if process is terminated, false otherwise
  873.      */
  874.     public function isTerminated()
  875.     {
  876.         $this->updateStatus(false);
  878.         return self::STATUS_TERMINATED == $this->status;
  879.     }
  881.     /**
  882.      * Gets the process status.
  883.      *
  884.      * The status is one of: ready, started, terminated.
  885.      *
  886.      * @return string The current process status
  887.      */
  888.     public function getStatus()
  889.     {
  890.         $this->updateStatus(false);
  892.         return $this->status;
  893.     }
  895.     /**
  896.      * Stops the process.
  897.      *
  898.      * @param int|float $timeout The timeout in seconds
  899.      * @param int       $signal  A POSIX signal to send in case the process has not stop at timeout, default is SIGKILL (9)
  900.      *
  901.      * @return int|null The exit-code of the process or null if it's not running
  902.      */
  903.     public function stop($timeout = 10, $signal = null)
  904.     {
  905.         $timeoutMicro = microtime(true) + $timeout;
  906.         if ($this->isRunning()) {
  907.             // given SIGTERM may not be defined and that "proc_terminate" uses the constant value and not the constant itself, we use the same here
  908.             $this->doSignal(15, false);
  909.             do {
  910.                 usleep(1000);
  911.             } while ($this->isRunning() && microtime(true) < $timeoutMicro);
  913.             if ($this->isRunning()) {
  914.                 // Avoid exception here: process is supposed to be running, but it might have stopped just
  915.                 // after this line. In any case, let's silently discard the error, we cannot do anything.
  916.                 $this->doSignal($signal ?: 9, false);
  917.             }
  918.         }
  920.         if ($this->isRunning()) {
  921.             if (isset($this->fallbackStatus['pid'])) {
  922.                 unset($this->fallbackStatus['pid']);
  924.                 return $this->stop(0, $signal);
  925.             }
  926.             $this->close();
  927.         }
  929.         return $this->exitcode;
  930.     }
  932.     /**
  933.      * Adds a line to the STDOUT stream.
  934.      *
  935.      * @internal
  936.      */
  937.     public function addOutput(string $line)
  938.     {
  939.         $this->lastOutputTime = microtime(true);
  941.         fseek($this->stdout, 0, \SEEK_END);
  942.         fwrite($this->stdout, $line);
  943.         fseek($this->stdout, $this->incrementalOutputOffset);
  944.     }
  946.     /**
  947.      * Adds a line to the STDERR stream.
  948.      *
  949.      * @internal
  950.      */
  951.     public function addErrorOutput(string $line)
  952.     {
  953.         $this->lastOutputTime = microtime(true);
  955.         fseek($this->stderr, 0, \SEEK_END);
  956.         fwrite($this->stderr, $line);
  957.         fseek($this->stderr, $this->incrementalErrorOutputOffset);
  958.     }
  960.     /**
  961.      * Gets the last output time in seconds.
  962.      *
  963.      * @return float|null The last output time in seconds or null if it isn't started
  964.      */
  965.     public function getLastOutputTime(): ?float
  966.     {
  967.         return $this->lastOutputTime;
  968.     }
  970.     /**
  971.      * Gets the command line to be executed.
  972.      *
  973.      * @return string The command to execute
  974.      */
  975.     public function getCommandLine()
  976.     {
  977.         return \is_array($this->commandline) ? implode(' ', array_map([$this, 'escapeArgument'], $this->commandline)) : $this->commandline;
  978.     }
  980.     /**
  981.      * Sets the command line to be executed.
  982.      *
  983.      * @param string|array $commandline The command to execute
  984.      *
  985.      * @return $this
  986.      *
  987.      * @deprecated since Symfony 4.2.
  988.      */
  989.     public function setCommandLine($commandline)
  990.     {
  991.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.2.', __METHOD__), \E_USER_DEPRECATED);
  993.         $this->commandline = $commandline;
  995.         return $this;
  996.     }
  998.     /**
  999.      * Gets the process timeout (max. runtime).
  1000.      *
  1001.      * @return float|null The timeout in seconds or null if it's disabled
  1002.      */
  1003.     public function getTimeout()
  1004.     {
  1005.         return $this->timeout;
  1006.     }
  1008.     /**
  1009.      * Gets the process idle timeout (max. time since last output).
  1010.      *
  1011.      * @return float|null The timeout in seconds or null if it's disabled
  1012.      */
  1013.     public function getIdleTimeout()
  1014.     {
  1015.         return $this->idleTimeout;
  1016.     }
  1018.     /**
  1019.      * Sets the process timeout (max. runtime) in seconds.
  1020.      *
  1021.      * To disable the timeout, set this value to null.
  1022.      *
  1023.      * @param int|float|null $timeout The timeout in seconds
  1024.      *
  1025.      * @return $this
  1026.      *
  1027.      * @throws InvalidArgumentException if the timeout is negative
  1028.      */
  1029.     public function setTimeout($timeout)
  1030.     {
  1031.         $this->timeout = $this->validateTimeout($timeout);
  1033.         return $this;
  1034.     }
  1036.     /**
  1037.      * Sets the process idle timeout (max. time since last output).
  1038.      *
  1039.      * To disable the timeout, set this value to null.
  1040.      *
  1041.      * @param int|float|null $timeout The timeout in seconds
  1042.      *
  1043.      * @return $this
  1044.      *
  1045.      * @throws LogicException           if the output is disabled
  1046.      * @throws InvalidArgumentException if the timeout is negative
  1047.      */
  1048.     public function setIdleTimeout($timeout)
  1049.     {
  1050.         if (null !== $timeout && $this->outputDisabled) {
  1051.             throw new LogicException('Idle timeout can not be set while the output is disabled.');
  1052.         }
  1054.         $this->idleTimeout = $this->validateTimeout($timeout);
  1056.         return $this;
  1057.     }
  1059.     /**
  1060.      * Enables or disables the TTY mode.
  1061.      *
  1062.      * @param bool $tty True to enabled and false to disable
  1063.      *
  1064.      * @return $this
  1065.      *
  1066.      * @throws RuntimeException In case the TTY mode is not supported
  1067.      */
  1068.     public function setTty($tty)
  1069.     {
  1070.         if ('\\' === \DIRECTORY_SEPARATOR && $tty) {
  1071.             throw new RuntimeException('TTY mode is not supported on Windows platform.');
  1072.         }
  1074.         if ($tty && !self::isTtySupported()) {
  1075.             throw new RuntimeException('TTY mode requires /dev/tty to be read/writable.');
  1076.         }
  1078.         $this->tty = (bool) $tty;
  1080.         return $this;
  1081.     }
  1083.     /**
  1084.      * Checks if the TTY mode is enabled.
  1085.      *
  1086.      * @return bool true if the TTY mode is enabled, false otherwise
  1087.      */
  1088.     public function isTty()
  1089.     {
  1090.         return $this->tty;
  1091.     }
  1093.     /**
  1094.      * Sets PTY mode.
  1095.      *
  1096.      * @param bool $bool
  1097.      *
  1098.      * @return $this
  1099.      */
  1100.     public function setPty($bool)
  1101.     {
  1102.         $this->pty = (bool) $bool;
  1104.         return $this;
  1105.     }
  1107.     /**
  1108.      * Returns PTY state.
  1109.      *
  1110.      * @return bool
  1111.      */
  1112.     public function isPty()
  1113.     {
  1114.         return $this->pty;
  1115.     }
  1117.     /**
  1118.      * Gets the working directory.
  1119.      *
  1120.      * @return string|null The current working directory or null on failure
  1121.      */
  1122.     public function getWorkingDirectory()
  1123.     {
  1124.         if (null === $this->cwd) {
  1125.             // getcwd() will return false if any one of the parent directories does not have
  1126.             // the readable or search mode set, even if the current directory does
  1127.             return getcwd() ?: null;
  1128.         }
  1130.         return $this->cwd;
  1131.     }
  1133.     /**
  1134.      * Sets the current working directory.
  1135.      *
  1136.      * @param string $cwd The new working directory
  1137.      *
  1138.      * @return $this
  1139.      */
  1140.     public function setWorkingDirectory($cwd)
  1141.     {
  1142.         $this->cwd = $cwd;
  1144.         return $this;
  1145.     }
  1147.     /**
  1148.      * Gets the environment variables.
  1149.      *
  1150.      * @return array The current environment variables
  1151.      */
  1152.     public function getEnv()
  1153.     {
  1154.         return $this->env;
  1155.     }
  1157.     /**
  1158.      * Sets the environment variables.
  1159.      *
  1160.      * Each environment variable value should be a string.
  1161.      * If it is an array, the variable is ignored.
  1162.      * If it is false or null, it will be removed when
  1163.      * env vars are otherwise inherited.
  1164.      *
  1165.      * That happens in PHP when 'argv' is registered into
  1166.      * the $_ENV array for instance.
  1167.      *
  1168.      * @param array $env The new environment variables
  1169.      *
  1170.      * @return $this
  1171.      */
  1172.     public function setEnv(array $env)
  1173.     {
  1174.         // Process can not handle env values that are arrays
  1175.         $env = array_filter($env, function ($value) {
  1176.             return !\is_array($value);
  1177.         });
  1179.         $this->env = $env;
  1181.         return $this;
  1182.     }
  1184.     /**
  1185.      * Gets the Process input.
  1186.      *
  1187.      * @return resource|string|\Iterator|null The Process input
  1188.      */
  1189.     public function getInput()
  1190.     {
  1191.         return $this->input;
  1192.     }
  1194.     /**
  1195.      * Sets the input.
  1196.      *
  1197.      * This content will be passed to the underlying process standard input.
  1198.      *
  1199.      * @param string|int|float|bool|resource|\Traversable|null $input The content
  1200.      *
  1201.      * @return $this
  1202.      *
  1203.      * @throws LogicException In case the process is running
  1204.      */
  1205.     public function setInput($input)
  1206.     {
  1207.         if ($this->isRunning()) {
  1208.             throw new LogicException('Input can not be set while the process is running.');
  1209.         }
  1211.         $this->input = ProcessUtils::validateInput(__METHOD__, $input);
  1213.         return $this;
  1214.     }
  1216.     /**
  1217.      * Sets whether environment variables will be inherited or not.
  1218.      *
  1219.      * @param bool $inheritEnv
  1220.      *
  1221.      * @return $this
  1222.      *
  1223.      * @deprecated since Symfony 4.4, env variables are always inherited
  1224.      */
  1225.     public function inheritEnvironmentVariables($inheritEnv = true)
  1226.     {
  1227.         @trigger_error(sprintf('The "%s()" method is deprecated since Symfony 4.4, env variables are always inherited.', __METHOD__), \E_USER_DEPRECATED);
  1229.         if (!$inheritEnv) {
  1230.             throw new InvalidArgumentException('Not inheriting environment variables is not supported.');
  1231.         }
  1233.         return $this;
  1234.     }
  1236.     /**
  1237.      * Performs a check between the timeout definition and the time the process started.
  1238.      *
  1239.      * In case you run a background process (with the start method), you should
  1240.      * trigger this method regularly to ensure the process timeout
  1241.      *
  1242.      * @throws ProcessTimedOutException In case the timeout was reached
  1243.      */
  1244.     public function checkTimeout()
  1245.     {
  1246.         if (self::STATUS_STARTED !== $this->status) {
  1247.             return;
  1248.         }
  1250.         if (null !== $this->timeout && $this->timeout < microtime(true) - $this->starttime) {
  1251.             $this->stop(0);
  1253.             throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_GENERAL);
  1254.         }
  1256.         if (null !== $this->idleTimeout && $this->idleTimeout < microtime(true) - $this->lastOutputTime) {
  1257.             $this->stop(0);
  1259.             throw new ProcessTimedOutException($this, ProcessTimedOutException::TYPE_IDLE);
  1260.         }
  1261.     }
  1263.     /**
  1264.      * Returns whether TTY is supported on the current operating system.
  1265.      */
  1266.     public static function isTtySupported(): bool
  1267.     {
  1268.         static $isTtySupported;
  1270.         if (null === $isTtySupported) {
  1271.             $isTtySupported = (bool) @proc_open('echo 1 >/dev/null', [['file', '/dev/tty', 'r'], ['file', '/dev/tty', 'w'], ['file', '/dev/tty', 'w']], $pipes);
  1272.         }
  1274.         return $isTtySupported;
  1275.     }
  1277.     /**
  1278.      * Returns whether PTY is supported on the current operating system.
  1279.      *
  1280.      * @return bool
  1281.      */
  1282.     public static function isPtySupported()
  1283.     {
  1284.         static $result;
  1286.         if (null !== $result) {
  1287.             return $result;
  1288.         }
  1290.         if ('\\' === \DIRECTORY_SEPARATOR) {
  1291.             return $result = false;
  1292.         }
  1294.         return $result = (bool) @proc_open('echo 1 >/dev/null', [['pty'], ['pty'], ['pty']], $pipes);
  1295.     }
  1297.     /**
  1298.      * Creates the descriptors needed by the proc_open.
  1299.      */
  1300.     private function getDescriptors(): array
  1301.     {
  1302.         if ($this->input instanceof \Iterator) {
  1303.             $this->input->rewind();
  1304.         }
  1305.         if ('\\' === \DIRECTORY_SEPARATOR) {
  1306.             $this->processPipes = new WindowsPipes($this->input, !$this->outputDisabled || $this->hasCallback);
  1307.         } else {
  1308.             $this->processPipes = new UnixPipes($this->isTty(), $this->isPty(), $this->input, !$this->outputDisabled || $this->hasCallback);
  1309.         }
  1311.         return $this->processPipes->getDescriptors();
  1312.     }
  1314.     /**
  1315.      * Builds up the callback used by wait().
  1316.      *
  1317.      * The callbacks adds all occurred output to the specific buffer and calls
  1318.      * the user callback (if present) with the received output.
  1319.      *
  1320.      * @param callable|null $callback The user defined PHP callback
  1321.      *
  1322.      * @return \Closure A PHP closure
  1323.      */
  1324.     protected function buildCallback(callable $callback = null)
  1325.     {
  1326.         if ($this->outputDisabled) {
  1327.             return function ($type, $data) use ($callback): bool {
  1328.                 return null !== $callback && $callback($type, $data);
  1329.             };
  1330.         }
  1332.         $out = self::OUT;
  1334.         return function ($type, $data) use ($callback, $out): bool {
  1335.             if ($out == $type) {
  1336.                 $this->addOutput($data);
  1337.             } else {
  1338.                 $this->addErrorOutput($data);
  1339.             }
  1341.             return null !== $callback && $callback($type, $data);
  1342.         };
  1343.     }
  1345.     /**
  1346.      * Updates the status of the process, reads pipes.
  1347.      *
  1348.      * @param bool $blocking Whether to use a blocking read call
  1349.      */
  1350.     protected function updateStatus($blocking)
  1351.     {
  1352.         if (self::STATUS_STARTED !== $this->status) {
  1353.             return;
  1354.         }
  1356.         $this->processInformation = proc_get_status($this->process);
  1357.         $running = $this->processInformation['running'];
  1359.         $this->readPipes($running && $blocking, '\\' !== \DIRECTORY_SEPARATOR || !$running);
  1361.         if ($this->fallbackStatus && $this->isSigchildEnabled()) {
  1362.             $this->processInformation = $this->fallbackStatus + $this->processInformation;
  1363.         }
  1365.         if (!$running) {
  1366.             $this->close();
  1367.         }
  1368.     }
  1370.     /**
  1371.      * Returns whether PHP has been compiled with the '--enable-sigchild' option or not.
  1372.      *
  1373.      * @return bool
  1374.      */
  1375.     protected function isSigchildEnabled()
  1376.     {
  1377.         if (null !== self::$sigchild) {
  1378.             return self::$sigchild;
  1379.         }
  1381.         if (!\function_exists('phpinfo')) {
  1382.             return self::$sigchild = false;
  1383.         }
  1385.         ob_start();
  1386.         phpinfo(\INFO_GENERAL);
  1388.         return self::$sigchild = false !== strpos(ob_get_clean(), '--enable-sigchild');
  1389.     }
  1391.     /**
  1392.      * Reads pipes for the freshest output.
  1393.      *
  1394.      * @param string $caller   The name of the method that needs fresh outputs
  1395.      * @param bool   $blocking Whether to use blocking calls or not
  1396.      *
  1397.      * @throws LogicException in case output has been disabled or process is not started
  1398.      */
  1399.     private function readPipesForOutput(string $caller, bool $blocking = false)
  1400.     {
  1401.         if ($this->outputDisabled) {
  1402.             throw new LogicException('Output has been disabled.');
  1403.         }
  1405.         $this->requireProcessIsStarted($caller);
  1407.         $this->updateStatus($blocking);
  1408.     }
  1410.     /**
  1411.      * Validates and returns the filtered timeout.
  1412.      *
  1413.      * @throws InvalidArgumentException if the given timeout is a negative number
  1414.      */
  1415.     private function validateTimeout(?float $timeout): ?float
  1416.     {
  1417.         $timeout = (float) $timeout;
  1419.         if (0.0 === $timeout) {
  1420.             $timeout = null;
  1421.         } elseif ($timeout < 0) {
  1422.             throw new InvalidArgumentException('The timeout value must be a valid positive integer or float number.');
  1423.         }
  1425.         return $timeout;
  1426.     }
  1428.     /**
  1429.      * Reads pipes, executes callback.
  1430.      *
  1431.      * @param bool $blocking Whether to use blocking calls or not
  1432.      * @param bool $close    Whether to close file handles or not
  1433.      */
  1434.     private function readPipes(bool $blocking, bool $close)
  1435.     {
  1436.         $result = $this->processPipes->readAndWrite($blocking, $close);
  1438.         $callback = $this->callback;
  1439.         foreach ($result as $type => $data) {
  1440.             if (3 !== $type) {
  1441.                 $callback(self::STDOUT === $type ? self::OUT : self::ERR, $data);
  1442.             } elseif (!isset($this->fallbackStatus['signaled'])) {
  1443.                 $this->fallbackStatus['exitcode'] = (int) $data;
  1444.             }
  1445.         }
  1446.     }
  1448.     /**
  1449.      * Closes process resource, closes file handles, sets the exitcode.
  1450.      *
  1451.      * @return int The exitcode
  1452.      */
  1453.     private function close(): int
  1454.     {
  1455.         $this->processPipes->close();
  1456.         if (\is_resource($this->process)) {
  1457.             proc_close($this->process);
  1458.         }
  1459.         $this->exitcode = $this->processInformation['exitcode'];
  1460.         $this->status = self::STATUS_TERMINATED;
  1462.         if (-1 === $this->exitcode) {
  1463.             if ($this->processInformation['signaled'] && 0 < $this->processInformation['termsig']) {
  1464.                 // if process has been signaled, no exitcode but a valid termsig, apply Unix convention
  1465.                 $this->exitcode = 128 + $this->processInformation['termsig'];
  1466.             } elseif ($this->isSigchildEnabled()) {
  1467.                 $this->processInformation['signaled'] = true;
  1468.                 $this->processInformation['termsig'] = -1;
  1469.             }
  1470.         }
  1472.         // Free memory from self-reference callback created by buildCallback
  1473.         // Doing so in other contexts like __destruct or by garbage collector is ineffective
  1474.         // Now pipes are closed, so the callback is no longer necessary
  1475.         $this->callback = null;
  1477.         return $this->exitcode;
  1478.     }
  1480.     /**
  1481.      * Resets data related to the latest run of the process.
  1482.      */
  1483.     private function resetProcessData()
  1484.     {
  1485.         $this->starttime = null;
  1486.         $this->callback = null;
  1487.         $this->exitcode = null;
  1488.         $this->fallbackStatus = [];
  1489.         $this->processInformation = null;
  1490.         $this->stdout = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+b');
  1491.         $this->stderr = fopen('php://temp/maxmemory:'.(1024 * 1024), 'w+b');
  1492.         $this->process = null;
  1493.         $this->latestSignal = null;
  1494.         $this->status = self::STATUS_READY;
  1495.         $this->incrementalOutputOffset = 0;
  1496.         $this->incrementalErrorOutputOffset = 0;
  1497.     }
  1499.     /**
  1500.      * Sends a POSIX signal to the process.
  1501.      *
  1502.      * @param int  $signal         A valid POSIX signal (see https://php.net/pcntl.constants)
  1503.      * @param bool $throwException Whether to throw exception in case signal failed
  1504.      *
  1505.      * @return bool True if the signal was sent successfully, false otherwise
  1506.      *
  1507.      * @throws LogicException   In case the process is not running
  1508.      * @throws RuntimeException In case --enable-sigchild is activated and the process can't be killed
  1509.      * @throws RuntimeException In case of failure
  1510.      */
  1511.     private function doSignal(int $signal, bool $throwException): bool
  1512.     {
  1513.         if (null === $pid = $this->getPid()) {
  1514.             if ($throwException) {
  1515.                 throw new LogicException('Can not send signal on a non running process.');
  1516.             }
  1518.             return false;
  1519.         }
  1521.         if ('\\' === \DIRECTORY_SEPARATOR) {
  1522.             exec(sprintf('taskkill /F /T /PID %d 2>&1', $pid), $output, $exitCode);
  1523.             if ($exitCode && $this->isRunning()) {
  1524.                 if ($throwException) {
  1525.                     throw new RuntimeException(sprintf('Unable to kill the process (%s).', implode(' ', $output)));
  1526.                 }
  1528.                 return false;
  1529.             }
  1530.         } else {
  1531.             if (!$this->isSigchildEnabled()) {
  1532.                 $ok = @proc_terminate($this->process, $signal);
  1533.             } elseif (\function_exists('posix_kill')) {
  1534.                 $ok = @posix_kill($pid, $signal);
  1535.             } elseif ($ok = proc_open(sprintf('kill -%d %d', $signal, $pid), [2 => ['pipe', 'w']], $pipes)) {
  1536.                 $ok = false === fgets($pipes[2]);
  1537.             }
  1538.             if (!$ok) {
  1539.                 if ($throwException) {
  1540.                     throw new RuntimeException(sprintf('Error while sending signal "%s".', $signal));
  1541.                 }
  1543.                 return false;
  1544.             }
  1545.         }
  1547.         $this->latestSignal = $signal;
  1548.         $this->fallbackStatus['signaled'] = true;
  1549.         $this->fallbackStatus['exitcode'] = -1;
  1550.         $this->fallbackStatus['termsig'] = $this->latestSignal;
  1552.         return true;
  1553.     }
  1555.     private function prepareWindowsCommandLine(string $cmd, array &$env): string
  1556.     {
  1557.         $uid = uniqid('', true);
  1558.         $varCount = 0;
  1559.         $varCache = [];
  1560.         $cmd = preg_replace_callback(
  1561.             '/"(?:(
  1562.                 [^"%!^]*+
  1563.                 (?:
  1564.                     (?: !LF! | "(?:\^[%!^])?+" )
  1565.                     [^"%!^]*+
  1566.                 )++
  1567.             ) | [^"]*+ )"/x',
  1568.             function ($m) use (&$env, &$varCache, &$varCount, $uid) {
  1569.                 if (!isset($m[1])) {
  1570.                     return $m[0];
  1571.                 }
  1572.                 if (isset($varCache[$m[0]])) {
  1573.                     return $varCache[$m[0]];
  1574.                 }
  1575.                 if (false !== strpos($value = $m[1], "\0")) {
  1576.                     $value = str_replace("\0", '?', $value);
  1577.                 }
  1578.                 if (false === strpbrk($value, "\"%!\n")) {
  1579.                     return '"'.$value.'"';
  1580.                 }
  1582.                 $value = str_replace(['!LF!', '"^!"', '"^%"', '"^^"', '""'], ["\n", '!', '%', '^', '"'], $value);
  1583.                 $value = '"'.preg_replace('/(\\\\*)"/', '$1$1\\"', $value).'"';
  1584.                 $var = $uid.++$varCount;
  1586.                 $env[$var] = $value;
  1588.                 return $varCache[$m[0]] = '!'.$var.'!';
  1589.             },
  1590.             $cmd
  1591.         );
  1593.         $cmd = 'cmd /V:ON /E:ON /D /C ('.str_replace("\n", ' ', $cmd).')';
  1594.         foreach ($this->processPipes->getFiles() as $offset => $filename) {
  1595.             $cmd .= ' '.$offset.'>"'.$filename.'"';
  1596.         }
  1598.         return $cmd;
  1599.     }
  1601.     /**
  1602.      * Ensures the process is running or terminated, throws a LogicException if the process has a not started.
  1603.      *
  1604.      * @throws LogicException if the process has not run
  1605.      */
  1606.     private function requireProcessIsStarted(string $functionName)
  1607.     {
  1608.         if (!$this->isStarted()) {
  1609.             throw new LogicException(sprintf('Process must be started before calling "%s()".', $functionName));
  1610.         }
  1611.     }
  1613.     /**
  1614.      * Ensures the process is terminated, throws a LogicException if the process has a status different than "terminated".
  1615.      *
  1616.      * @throws LogicException if the process is not yet terminated
  1617.      */
  1618.     private function requireProcessIsTerminated(string $functionName)
  1619.     {
  1620.         if (!$this->isTerminated()) {
  1621.             throw new LogicException(sprintf('Process must be terminated before calling "%s()".', $functionName));
  1622.         }
  1623.     }
  1625.     /**
  1626.      * Escapes a string to be used as a shell argument.
  1627.      */
  1628.     private function escapeArgument(?string $argument): string
  1629.     {
  1630.         if ('' === $argument || null === $argument) {
  1631.             return '""';
  1632.         }
  1633.         if ('\\' !== \DIRECTORY_SEPARATOR) {
  1634.             return "'".str_replace("'", "'\\''", $argument)."'";
  1635.         }
  1636.         if (false !== strpos($argument, "\0")) {
  1637.             $argument = str_replace("\0", '?', $argument);
  1638.         }
  1639.         if (!preg_match('/[\/()%!^"<>&|\s]/', $argument)) {
  1640.             return $argument;
  1641.         }
  1642.         $argument = preg_replace('/(\\\\+)$/', '$1$1', $argument);
  1644.         return '"'.str_replace(['"', '^', '%', '!', "\n"], ['""', '"^^"', '"^%"', '"^!"', '!LF!'], $argument).'"';
  1645.     }
  1647.     private function replacePlaceholders(string $commandline, array $env)
  1648.     {
  1649.         return preg_replace_callback('/"\$\{:([_a-zA-Z]++[_a-zA-Z0-9]*+)\}"/', function ($matches) use ($commandline, $env) {
  1650.             if (!isset($env[$matches[1]]) || false === $env[$matches[1]]) {
  1651.                 throw new InvalidArgumentException(sprintf('Command line is missing a value for parameter "%s": ', $matches[1]).$commandline);
  1652.             }
  1654.             return $this->escapeArgument($env[$matches[1]]);
  1655.         }, $commandline);
  1656.     }
  1658.     private function getDefaultEnv(): array
  1659.     {
  1660.         $env = [];
  1662.         foreach ($_SERVER as $k => $v) {
  1663.             if (\is_string($v) && false !== $v = getenv($k)) {
  1664.                 $env[$k] = $v;
  1665.             }
  1666.         }
  1668.         foreach ($_ENV as $k => $v) {
  1669.             if (\is_string($v)) {
  1670.                 $env[$k] = $v;
  1671.             }
  1672.         }
  1674.         return $env;
  1675.     }
  1676. }