<form method="POST">
    <h3>Editing: ConsoleProcessus.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/**
 * Hoa
 *
 *
 * @license
 *
 * New BSD License
 *
 * Copyright © 2007-2017, Hoa community. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Hoa nor the names of its contributors may be
 *       used to endorse or promote products derived from this software without
 *       specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot;
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

namespace Psy\Readline\Hoa;

/**
 * Manipulate a processus as a stream.
 */
class ConsoleProcessus extends Stream implements StreamIn, StreamOut, StreamPathable
{
    /**
     * Signal: terminal line hangup (terminate process).
     */
    const SIGHUP = 1;

    /**
     * Signal: interrupt program (terminate process).
     */
    const SIGINT = 2;

    /**
     * Signal: quit program (create core image).
     */
    const SIGQUIT = 3;

    /**
     * Signal: illegal instruction (create core image).
     */
    const SIGILL = 4;

    /**
     * Signal: trace trap (create core image).
     */
    const SIGTRAP = 5;

    /**
     * Signal: abort program, formerly SIGIOT (create core image).
     */
    const SIGABRT = 6;

    /**
     * Signal: emulate instruction executed (create core image).
     */
    const SIGEMT = 7;

    /**
     * Signal: floating-point exception (create core image).
     */
    const SIGFPE = 8;

    /**
     * Signal: kill program (terminate process).
     */
    const SIGKILL = 9;

    /**
     * Signal: bus error.
     */
    const SIGBUS = 10;

    /**
     * Signal: segmentation violation (create core image).
     */
    const SIGSEGV = 11;

    /**
     * Signal: non-existent system call invoked (create core image).
     */
    const SIGSYS = 12;

    /**
     * Signal: write on a pipe with no reader (terminate process).
     */
    const SIGPIPE = 13;

    /**
     * Signal: real-time timer expired (terminate process).
     */
    const SIGALRM = 14;

    /**
     * Signal: software termination signal (terminate process).
     */
    const SIGTERM = 15;

    /**
     * Signal: urgent condition present on socket (discard signal).
     */
    const SIGURG = 16;

    /**
     * Signal: stop, cannot be caught or ignored  (stop proces).
     */
    const SIGSTOP = 17;

    /**
     * Signal: stop signal generated from keyboard (stop process).
     */
    const SIGTSTP = 18;

    /**
     * Signal: continue after stop (discard signal).
     */
    const SIGCONT = 19;

    /**
     * Signal: child status has changed (discard signal).
     */
    const SIGCHLD = 20;

    /**
     * Signal: background read attempted from control terminal (stop process).
     */
    const SIGTTIN = 21;

    /**
     * Signal: background write attempted to control terminal (stop process).
     */
    const SIGTTOU = 22;

    /**
     * Signal: I/O is possible on a descriptor, see fcntl(2) (discard signal).
     */
    const SIGIO = 23;

    /**
     * Signal: cpu time limit exceeded, see setrlimit(2) (terminate process).
     */
    const SIGXCPU = 24;

    /**
     * Signal: file size limit exceeded, see setrlimit(2) (terminate process).
     */
    const SIGXFSZ = 25;

    /**
     * Signal: virtual time alarm, see setitimer(2) (terminate process).
     */
    const SIGVTALRM = 26;

    /**
     * Signal: profiling timer alarm, see setitimer(2) (terminate process).
     */
    const SIGPROF = 27;

    /**
     * Signal: Window size change (discard signal).
     */
    const SIGWINCH = 28;

    /**
     * Signal: status request from keyboard (discard signal).
     */
    const SIGINFO = 29;

    /**
     * Signal: User defined signal 1 (terminate process).
     */
    const SIGUSR1 = 30;

    /**
     * Signal: User defined signal 2 (terminate process).
     */
    const SIGUSR2 = 31;

    /**
     * Command name.
     */
    protected $_command = null;

    /**
     * Command options (options =&gt; value, or input).
     */
    protected $_options = [];

    /**
     * Current working directory.
     */
    protected $_cwd = null;

    /**
     * Environment.
     */
    protected $_environment = null;

    /**
     * Timeout.
     */
    protected $_timeout = 30;

    /**
     * Descriptor.
     */
    protected $_descriptors = [
        0 =&gt; ['pipe', 'r'],
        1 =&gt; ['pipe', 'w'],
        2 =&gt; ['pipe', 'w'],
    ];

    /**
     * Pipe descriptors of the processus.
     */
    protected $_pipes = null;

    /**
     * Seekability of pipes.
     */
    protected $_seekable = [];

    /**
     * Start a processus.
     */
    public function __construct(
        string $command,
        ?array $options = null,
        ?array $descriptors = null,
        ?string $cwd = null,
        ?array $environment = null,
        int $timeout = 30
    ) {
        $this-&gt;setCommand($command);

        if (null !== $options) {
            $this-&gt;setOptions($options);
        }

        if (null !== $descriptors) {
            $this-&gt;_descriptors = [];

            foreach ($descriptors as $descriptor =&gt; $nature) {
                if (isset($this-&gt;_descriptors[$descriptor])) {
                    throw new ConsoleException('Pipe descriptor %d already exists, cannot '.'redefine it.', 0, $descriptor);
                }

                $this-&gt;_descriptors[$descriptor] = $nature;
            }
        }

        $this-&gt;setCwd($cwd ?: \getcwd());

        if (null !== $environment) {
            $this-&gt;setEnvironment($environment);
        }

        $this-&gt;setTimeout($timeout);
        parent::__construct($this-&gt;getCommandLine(), null, true);
        $this-&gt;getListener()-&gt;addIds(['input', 'output', 'timeout', 'start', 'stop']);

        return;
    }

    /**
     * Open the stream and return the associated resource.
     */
    protected function &amp;_open(string $streamName, ?StreamContext $context = null)
    {
        $out = @\proc_open(
            $streamName,
            $this-&gt;_descriptors,
            $this-&gt;_pipes,
            $this-&gt;getCwd(),
            $this-&gt;getEnvironment()
        );

        if (false === $out) {
            throw new ConsoleException('Something wrong happen when running %s.', 1, $streamName);
        }

        return $out;
    }

    /**
     * Close the current stream.
     */
    protected function _close(): bool
    {
        foreach ($this-&gt;_pipes as $pipe) {
            @\fclose($pipe);
        }

        return (bool) @\proc_close($this-&gt;getStream());
    }

    /**
     * Run the process and fire events (amongst start, stop, input, output and
     * timeout).
     * If an event returns false, it will close the current pipe.
     * For a simple run without firing events, use the $this-&gt;open() method.
     */
    public function run()
    {
        if (false === $this-&gt;isOpened()) {
            $this-&gt;open();
        } else {
            $this-&gt;_close();
            $this-&gt;_setStream($this-&gt;_open(
                $this-&gt;getStreamName(),
                $this-&gt;getStreamContext()
            ));
        }

        $this-&gt;getListener()-&gt;fire('start', new EventBucket());

        $_read = [];
        $_write = [];
        $_except = [];

        foreach ($this-&gt;_pipes as $p =&gt; $pipe) {
            switch ($this-&gt;_descriptors[$p][1]) {
                case 'r':
                    \stream_set_blocking($pipe, false);
                    $_write[] = $pipe;

                    break;

                case 'w':
                case 'a':
                    \stream_set_blocking($pipe, true);
                    $_read[] = $pipe;

                    break;
            }
        }

        while (true) {
            foreach ($_read as $i =&gt; $r) {
                if (false === \is_resource($r)) {
                    unset($_read[$i]);
                }
            }

            foreach ($_write as $i =&gt; $w) {
                if (false === \is_resource($w)) {
                    unset($_write[$i]);
                }
            }

            foreach ($_except as $i =&gt; $e) {
                if (false === \is_resource($e)) {
                    unset($_except[$i]);
                }
            }

            if (empty($_read) &amp;&amp; empty($_write) &amp;&amp; empty($_except)) {
                break;
            }

            $read = $_read;
            $write = $_write;
            $except = $_except;
            $select = \stream_select($read, $write, $except, $this-&gt;getTimeout());

            if (0 === $select) {
                $this-&gt;getListener()-&gt;fire('timeout', new EventBucket());

                break;
            }

            foreach ($read as $i =&gt; $_r) {
                $pipe = \array_search($_r, $this-&gt;_pipes);
                $line = $this-&gt;readLine($pipe);

                if (false === $line) {
                    $result = [false];
                } else {
                    $result = $this-&gt;getListener()-&gt;fire(
                        'output',
                        new EventBucket([
                            'pipe' =&gt; $pipe,
                            'line' =&gt; $line,
                        ])
                    );
                }

                if (true === \feof($_r) || \in_array(false, $result, true)) {
                    \fclose($_r);
                    unset($_read[$i]);

                    break;
                }
            }

            foreach ($write as $j =&gt; $_w) {
                $result = $this-&gt;getListener()-&gt;fire(
                    'input',
                    new EventBucket([
                        'pipe' =&gt; \array_search($_w, $this-&gt;_pipes),
                    ])
                );

                if (true === \feof($_w) || \in_array(false, $result, true)) {
                    \fclose($_w);
                    unset($_write[$j]);
                }
            }

            if (empty($_read)) {
                break;
            }
        }

        $this-&gt;getListener()-&gt;fire('stop', new EventBucket());

        return;
    }

    /**
     * Get pipe resource.
     */
    protected function getPipe(int $pipe)
    {
        if (!isset($this-&gt;_pipes[$pipe])) {
            throw new ConsoleException('Pipe descriptor %d does not exist, cannot read from it.', 2, $pipe);
        }

        return $this-&gt;_pipes[$pipe];
    }

    /**
     * Check if a pipe is seekable or not.
     */
    protected function isPipeSeekable(int $pipe): bool
    {
        if (!isset($this-&gt;_seekable[$pipe])) {
            $_pipe = $this-&gt;getPipe($pipe);
            $data = \stream_get_meta_data($_pipe);
            $this-&gt;_seekable[$pipe] = $data['seekable'];
        }

        return $this-&gt;_seekable[$pipe];
    }

    /**
     * Test for end-of-file.
     */
    public function eof(int $pipe = 1): bool
    {
        return \feof($this-&gt;getPipe($pipe));
    }

    /**
     * Read n characters.
     */
    public function read(int $length, int $pipe = 1)
    {
        if (0 &gt; $length) {
            throw new ConsoleException('Length must be greater than 0, given %d.', 3, $length);
        }

        return \fread($this-&gt;getPipe($pipe), $length);
    }

    /**
     * Alias of $this-&gt;read().
     */
    public function readString(int $length, int $pipe = 1)
    {
        return $this-&gt;read($length, $pipe);
    }

    /**
     * Read a character.
     */
    public function readCharacter(int $pipe = 1)
    {
        return \fgetc($this-&gt;getPipe($pipe));
    }

    /**
     * Read a boolean.
     */
    public function readBoolean(int $pipe = 1)
    {
        return (bool) $this-&gt;read(1, $pipe);
    }

    /**
     * Read an integer.
     */
    public function readInteger(int $length = 1, int $pipe = 1)
    {
        return (int) $this-&gt;read($length, $pipe);
    }

    /**
     * Read a float.
     */
    public function readFloat(int $length = 1, int $pipe = 1)
    {
        return (float) $this-&gt;read($length, $pipe);
    }

    /**
     * Read an array.
     * Alias of the $this-&gt;scanf() method.
     */
    public function readArray(?string $format = null, int $pipe = 1)
    {
        return $this-&gt;scanf($format, $pipe);
    }

    /**
     * Read a line.
     */
    public function readLine(int $pipe = 1)
    {
        return \stream_get_line($this-&gt;getPipe($pipe), 1 &lt;&lt; 15, &quot;\n&quot;);
    }

    /**
     * Read all, i.e. read as much as possible.
     */
    public function readAll(int $offset = -1, int $pipe = 1)
    {
        $_pipe = $this-&gt;getPipe($pipe);

        if (true === $this-&gt;isPipeSeekable($pipe)) {
            $offset += \ftell($_pipe);
        } else {
            $offset = -1;
        }

        return \stream_get_contents($_pipe, -1, $offset);
    }

    /**
     * Parse input from a stream according to a format.
     */
    public function scanf(string $format, int $pipe = 1): array
    {
        return \fscanf($this-&gt;getPipe($pipe), $format);
    }

    /**
     * Write n characters.
     */
    public function write(string $string, int $length, int $pipe = 0)
    {
        if (0 &gt; $length) {
            throw new ConsoleException('Length must be greater than 0, given %d.', 4, $length);
        }

        return \fwrite($this-&gt;getPipe($pipe), $string, $length);
    }

    /**
     * Write a string.
     */
    public function writeString(string $string, int $pipe = 0)
    {
        $string = (string) $string;

        return $this-&gt;write($string, \strlen($string), $pipe);
    }

    /**
     * Write a character.
     */
    public function writeCharacter(string $char, int $pipe = 0)
    {
        return $this-&gt;write((string) $char[0], 1, $pipe);
    }

    /**
     * Write a boolean.
     */
    public function writeBoolean(bool $boolean, int $pipe = 0)
    {
        return $this-&gt;write((string) (bool) $boolean, 1, $pipe);
    }

    /**
     * Write an integer.
     */
    public function writeInteger(int $integer, int $pipe = 0)
    {
        $integer = (string) (int) $integer;

        return $this-&gt;write($integer, \strlen($integer), $pipe);
    }

    /**
     * Write a float.
     */
    public function writeFloat(float $float, int $pipe = 0)
    {
        $float = (string) (float) $float;

        return $this-&gt;write($float, \strlen($float), $pipe);
    }

    /**
     * Write an array.
     */
    public function writeArray(array $array, int $pipe = 0)
    {
        $array = \var_export($array, true);

        return $this-&gt;write($array, \strlen($array), $pipe);
    }

    /**
     * Write a line.
     */
    public function writeLine(string $line, int $pipe = 0)
    {
        if (false === $n = \strpos($line, &quot;\n&quot;)) {
            return $this-&gt;write($line.&quot;\n&quot;, \strlen($line) + 1, $pipe);
        }

        ++$n;

        return $this-&gt;write(\substr($line, 0, $n), $n, $pipe);
    }

    /**
     * Write all, i.e. as much as possible.
     */
    public function writeAll(string $string, int $pipe = 0)
    {
        return $this-&gt;write($string, \strlen($string), $pipe);
    }

    /**
     * Truncate a file to a given length.
     */
    public function truncate(int $size, int $pipe = 0): bool
    {
        return \ftruncate($this-&gt;getPipe($pipe), $size);
    }

    /**
     * Get filename component of path.
     */
    public function getBasename(): string
    {
        return \basename($this-&gt;getCommand());
    }

    /**
     * Get directory name component of path.
     */
    public function getDirname(): string
    {
        return \dirname($this-&gt;getCommand());
    }

    /**
     * Get status.
     */
    public function getStatus(): array
    {
        return \proc_get_status($this-&gt;getStream());
    }

    /**
     * Get exit code (alias of $this-&gt;getStatus()['exitcode']);.
     */
    public function getExitCode(): int
    {
        $handle = $this-&gt;getStatus();

        return $handle['exitcode'];
    }

    /**
     * Whether the processus have ended successfully.
     *
     * @return bool
     */
    public function isSuccessful(): bool
    {
        return 0 === $this-&gt;getExitCode();
    }

    /**
     * Terminate the process.
     *
     * Valid signals are self::SIGHUP, SIGINT, SIGQUIT, SIGABRT, SIGKILL,
     * SIGALRM and SIGTERM.
     */
    public function terminate(int $signal = self::SIGTERM): bool
    {
        return \proc_terminate($this-&gt;getStream(), $signal);
    }

    /**
     * Set command name.
     */
    protected function setCommand(string $command)
    {
        $old = $this-&gt;_command;
        $this-&gt;_command = \escapeshellcmd($command);

        return $old;
    }

    /**
     * Get command name.
     */
    public function getCommand()
    {
        return $this-&gt;_command;
    }

    /**
     * Set command options.
     */
    protected function setOptions(array $options): array
    {
        foreach ($options as &amp;$option) {
            $option = \escapeshellarg($option);
        }

        $old = $this-&gt;_options;
        $this-&gt;_options = $options;

        return $old;
    }

    /**
     * Get options.
     */
    public function getOptions(): array
    {
        return $this-&gt;_options;
    }

    /**
     * Get command-line.
     */
    public function getCommandLine(): string
    {
        $out = $this-&gt;getCommand();

        foreach ($this-&gt;getOptions() as $key =&gt; $value) {
            if (!\is_int($key)) {
                $out .= ' '.$key.'='.$value;
            } else {
                $out .= ' '.$value;
            }
        }

        return $out;
    }

    /**
     * Set current working directory of the process.
     */
    protected function setCwd(string $cwd)
    {
        $old = $this-&gt;_cwd;
        $this-&gt;_cwd = $cwd;

        return $old;
    }

    /**
     * Get current working directory of the process.
     */
    public function getCwd(): string
    {
        return $this-&gt;_cwd;
    }

    /**
     * Set environment of the process.
     */
    protected function setEnvironment(array $environment)
    {
        $old = $this-&gt;_environment;
        $this-&gt;_environment = $environment;

        return $old;
    }

    /**
     * Get environment of the process.
     */
    public function getEnvironment()
    {
        return $this-&gt;_environment;
    }

    /**
     * Set timeout of the process.
     */
    public function setTimeout(int $timeout)
    {
        $old = $this-&gt;_timeout;
        $this-&gt;_timeout = $timeout;

        return $old;
    }

    /**
     * Get timeout of the process.
     */
    public function getTimeout(): int
    {
        return $this-&gt;_timeout;
    }

    /**
     * Set process title.
     */
    public static function setTitle(string $title)
    {
        \cli_set_process_title($title);
    }

    /**
     * Get process title.
     */
    public static function getTitle()
    {
        return \cli_get_process_title();
    }

    /**
     * Found the place of a binary.
     */
    public static function locate(string $binary)
    {
        if (isset($_ENV['PATH'])) {
            $separator = ':';
            $path = &amp;$_ENV['PATH'];
        } elseif (isset($_SERVER['PATH'])) {
            $separator = ':';
            $path = &amp;$_SERVER['PATH'];
        } elseif (isset($_SERVER['Path'])) {
            $separator = ';';
            $path = &amp;$_SERVER['Path'];
        } else {
            return null;
        }

        foreach (\explode($separator, $path) as $directory) {
            if (true === \file_exists($out = $directory.\DIRECTORY_SEPARATOR.$binary)) {
                return $out;
            }
        }

        return null;
    }

    /**
     * Quick process execution.
     * Returns only the STDOUT.
     */
    public static function execute(string $commandLine, bool $escape = true): string
    {
        if (true === $escape) {
            $commandLine = \escapeshellcmd($commandLine);
        }

        return \rtrim(\shell_exec($commandLine) ?? '');
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>