@averay/codeformat 0.2.1 → 0.2.3

package/vendor/react/socket/src/SocketServer.php

@@ -0,0 +1,215 @@
+<?php
+
+namespace React\Socket;
+
+use Evenement\EventEmitter;
+use React\EventLoop\LoopInterface;
+
+final class SocketServer extends EventEmitter implements ServerInterface
+{
+    private $server;
+
+    /**
+     * The `SocketServer` class is the main class in this package that implements the `ServerInterface` and
+     * allows you to accept incoming streaming connections, such as plaintext TCP/IP or secure TLS connection streams.
+     *
+     * ```php
+     * $socket = new React\Socket\SocketServer('127.0.0.1:0');
+     * $socket = new React\Socket\SocketServer('127.0.0.1:8000');
+     * $socket = new React\Socket\SocketServer('127.0.0.1:8000', $context);
+     * ```
+     *
+     * This class takes an optional `LoopInterface|null $loop` parameter that can be used to
+     * pass the event loop instance to use for this object. You can use a `null` value
+     * here in order to use the [default loop](https://github.com/reactphp/event-loop#loop).
+     * This value SHOULD NOT be given unless you're sure you want to explicitly use a
+     * given event loop instance.
+     *
+     * @param string         $uri
+     * @param array          $context
+     * @param ?LoopInterface $loop
+     * @throws \InvalidArgumentException if the listening address is invalid
+     * @throws \RuntimeException if listening on this address fails (already in use etc.)
+     */
+    public function __construct($uri, array $context = array(), $loop = null)
+    {
+        if ($loop !== null && !$loop instanceof LoopInterface) { // manual type check to support legacy PHP < 7.1
+            throw new \InvalidArgumentException('Argument #3 ($loop) expected null|React\EventLoop\LoopInterface');
+        }
+
+        // apply default options if not explicitly given
+        $context += array(
+            'tcp' => array(),
+            'tls' => array(),
+            'unix' => array()
+        );
+
+        $scheme = 'tcp';
+        $pos = \strpos($uri, '://');
+        if ($pos !== false) {
+            $scheme = \substr($uri, 0, $pos);
+        }
+
+        if ($scheme === 'unix') {
+            $server = new UnixServer($uri, $loop, $context['unix']);
+        } elseif ($scheme === 'php') {
+            $server = new FdServer($uri, $loop);
+        } else {
+            if (preg_match('#^(?:\w+://)?\d+$#', $uri)) {
+                throw new \InvalidArgumentException(
+                    'Invalid URI given (EINVAL)',
+                    \defined('SOCKET_EINVAL') ? \SOCKET_EINVAL : (\defined('PCNTL_EINVAL') ? \PCNTL_EINVAL : 22)
+                );
+            }
+
+            $server = new TcpServer(str_replace('tls://', '', $uri), $loop, $context['tcp']);
+
+            if ($scheme === 'tls') {
+                $server = new SecureServer($server, $loop, $context['tls']);
+            }
+        }
+
+        $this->server = $server;
+
+        $that = $this;
+        $server->on('connection', function (ConnectionInterface $conn) use ($that) {
+            $that->emit('connection', array($conn));
+        });
+        $server->on('error', function (\Exception $error) use ($that) {
+            $that->emit('error', array($error));
+        });
+    }
+
+    public function getAddress()
+    {
+        return $this->server->getAddress();
+    }
+
+    public function pause()
+    {
+        $this->server->pause();
+    }
+
+    public function resume()
+    {
+        $this->server->resume();
+    }
+
+    public function close()
+    {
+        $this->server->close();
+    }
+
+    /**
+     * [internal] Internal helper method to accept new connection from given server socket
+     *
+     * @param resource $socket server socket to accept connection from
+     * @return resource new client socket if any
+     * @throws \RuntimeException if accepting fails
+     * @internal
+     */
+    public static function accept($socket)
+    {
+        $errno = 0;
+        $errstr = '';
+        \set_error_handler(function ($_, $error) use (&$errno, &$errstr) {
+            // Match errstr from PHP's warning message.
+            // stream_socket_accept(): accept failed: Connection timed out
+            $errstr = \preg_replace('#.*: #', '', $error);
+            $errno = SocketServer::errno($errstr);
+        });
+
+        $newSocket = \stream_socket_accept($socket, 0);
+
+        \restore_error_handler();
+
+        if (false === $newSocket) {
+            throw new \RuntimeException(
+                'Unable to accept new connection: ' . $errstr . self::errconst($errno),
+                $errno
+            );
+        }
+
+        return $newSocket;
+    }
+
+    /**
+     * [Internal] Returns errno value for given errstr
+     *
+     * The errno and errstr values describes the type of error that has been
+     * encountered. This method tries to look up the given errstr and find a
+     * matching errno value which can be useful to provide more context to error
+     * messages. It goes through the list of known errno constants when either
+     * `ext-sockets`, `ext-posix` or `ext-pcntl` is available to find an errno
+     * matching the given errstr.
+     *
+     * @param string $errstr
+     * @return int errno value (e.g. value of `SOCKET_ECONNREFUSED`) or 0 if not found
+     * @internal
+     * @copyright Copyright (c) 2023 Christian Lück, taken from https://github.com/clue/errno with permission
+     * @codeCoverageIgnore
+     */
+    public static function errno($errstr)
+    {
+        // PHP defines the required `strerror()` function through either `ext-sockets`, `ext-posix` or `ext-pcntl`
+        $strerror = \function_exists('socket_strerror') ? 'socket_strerror' : (\function_exists('posix_strerror') ? 'posix_strerror' : (\function_exists('pcntl_strerror') ? 'pcntl_strerror' : null));
+        if ($strerror !== null) {
+            assert(\is_string($strerror) && \is_callable($strerror));
+
+            // PHP defines most useful errno constants like `ECONNREFUSED` through constants in `ext-sockets` like `SOCKET_ECONNREFUSED`
+            // PHP also defines a hand full of errno constants like `EMFILE` through constants in `ext-pcntl` like `PCNTL_EMFILE`
+            // go through list of all defined constants like `SOCKET_E*` and `PCNTL_E*` and see if they match the given `$errstr`
+            foreach (\get_defined_constants(false) as $name => $value) {
+                if (\is_int($value) && (\strpos($name, 'SOCKET_E') === 0 || \strpos($name, 'PCNTL_E') === 0) && $strerror($value) === $errstr) {
+                    return $value;
+                }
+            }
+
+            // if we reach this, no matching errno constant could be found (unlikely when `ext-sockets` is available)
+            // go through list of all possible errno values from 1 to `MAX_ERRNO` and see if they match the given `$errstr`
+            for ($errno = 1, $max = \defined('MAX_ERRNO') ? \MAX_ERRNO : 4095; $errno <= $max; ++$errno) {
+                if ($strerror($errno) === $errstr) {
+                    return $errno;
+                }
+            }
+        }
+
+        // if we reach this, no matching errno value could be found (unlikely when either `ext-sockets`, `ext-posix` or `ext-pcntl` is available)
+        return 0;
+    }
+
+    /**
+     * [Internal] Returns errno constant name for given errno value
+     *
+     * The errno value describes the type of error that has been encountered.
+     * This method tries to look up the given errno value and find a matching
+     * errno constant name which can be useful to provide more context and more
+     * descriptive error messages. It goes through the list of known errno
+     * constants when either `ext-sockets` or `ext-pcntl` is available to find
+     * the matching errno constant name.
+     *
+     * Because this method is used to append more context to error messages, the
+     * constant name will be prefixed with a space and put between parenthesis
+     * when found.
+     *
+     * @param int $errno
+     * @return string e.g. ` (ECONNREFUSED)` or empty string if no matching const for the given errno could be found
+     * @internal
+     * @copyright Copyright (c) 2023 Christian Lück, taken from https://github.com/clue/errno with permission
+     * @codeCoverageIgnore
+     */
+    public static function errconst($errno)
+    {
+        // PHP defines most useful errno constants like `ECONNREFUSED` through constants in `ext-sockets` like `SOCKET_ECONNREFUSED`
+        // PHP also defines a hand full of errno constants like `EMFILE` through constants in `ext-pcntl` like `PCNTL_EMFILE`
+        // go through list of all defined constants like `SOCKET_E*` and `PCNTL_E*` and see if they match the given `$errno`
+        foreach (\get_defined_constants(false) as $name => $value) {
+            if ($value === $errno && (\strpos($name, 'SOCKET_E') === 0 || \strpos($name, 'PCNTL_E') === 0)) {
+                return ' (' . \substr($name, \strpos($name, '_') + 1) . ')';
+            }
+        }
+
+        // if we reach this, no matching errno constant could be found (unlikely when `ext-sockets` is available)
+        return '';
+    }
+}

package/vendor/react/socket/src/StreamEncryption.php

@@ -0,0 +1,158 @@
+<?php
+
+namespace React\Socket;
+
+use React\EventLoop\LoopInterface;
+use React\Promise\Deferred;
+use RuntimeException;
+use UnexpectedValueException;
+
+/**
+ * This class is considered internal and its API should not be relied upon
+ * outside of Socket.
+ *
+ * @internal
+ */
+class StreamEncryption
+{
+    private $loop;
+    private $method;
+    private $server;
+
+    public function __construct(LoopInterface $loop, $server = true)
+    {
+        $this->loop = $loop;
+        $this->server = $server;
+
+        // support TLSv1.0+ by default and exclude legacy SSLv2/SSLv3.
+        // As of PHP 7.2+ the main crypto method constant includes all TLS versions.
+        // As of PHP 5.6+ the crypto method is a bitmask, so we explicitly include all TLS versions.
+        // For legacy PHP < 5.6 the crypto method is a single value only and this constant includes all TLS versions.
+        // @link https://3v4l.org/9PSST
+        if ($server) {
+            $this->method = \STREAM_CRYPTO_METHOD_TLS_SERVER;
+
+            if (\PHP_VERSION_ID < 70200 && \PHP_VERSION_ID >= 50600) {
+                $this->method |= \STREAM_CRYPTO_METHOD_TLSv1_0_SERVER | \STREAM_CRYPTO_METHOD_TLSv1_1_SERVER | \STREAM_CRYPTO_METHOD_TLSv1_2_SERVER; // @codeCoverageIgnore
+            }
+        } else {
+            $this->method = \STREAM_CRYPTO_METHOD_TLS_CLIENT;
+
+            if (\PHP_VERSION_ID < 70200 && \PHP_VERSION_ID >= 50600) {
+                $this->method |= \STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT | \STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT | \STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT; // @codeCoverageIgnore
+            }
+        }
+    }
+
+    /**
+     * @param Connection $stream
+     * @return \React\Promise\PromiseInterface<Connection>
+     */
+    public function enable(Connection $stream)
+    {
+        return $this->toggle($stream, true);
+    }
+
+    /**
+     * @param Connection $stream
+     * @param bool $toggle
+     * @return \React\Promise\PromiseInterface<Connection>
+     */
+    public function toggle(Connection $stream, $toggle)
+    {
+        // pause actual stream instance to continue operation on raw stream socket
+        $stream->pause();
+
+        // TODO: add write() event to make sure we're not sending any excessive data
+
+        // cancelling this leaves this stream in an inconsistent state…
+        $deferred = new Deferred(function () {
+            throw new \RuntimeException();
+        });
+
+        // get actual stream socket from stream instance
+        $socket = $stream->stream;
+
+        // get crypto method from context options or use global setting from constructor
+        $method = $this->method;
+        $context = \stream_context_get_options($socket);
+        if (isset($context['ssl']['crypto_method'])) {
+            $method = $context['ssl']['crypto_method'];
+        }
+
+        $that = $this;
+        $toggleCrypto = function () use ($socket, $deferred, $toggle, $method, $that) {
+            $that->toggleCrypto($socket, $deferred, $toggle, $method);
+        };
+
+        $this->loop->addReadStream($socket, $toggleCrypto);
+
+        if (!$this->server) {
+            $toggleCrypto();
+        }
+
+        $loop = $this->loop;
+
+        return $deferred->promise()->then(function () use ($stream, $socket, $loop, $toggle) {
+            $loop->removeReadStream($socket);
+
+            $stream->encryptionEnabled = $toggle;
+            $stream->resume();
+
+            return $stream;
+        }, function($error) use ($stream, $socket, $loop) {
+            $loop->removeReadStream($socket);
+            $stream->resume();
+            throw $error;
+        });
+    }
+
+    /**
+     * @internal
+     * @param resource $socket
+     * @param Deferred<null> $deferred
+     * @param bool $toggle
+     * @param int $method
+     * @return void
+     */
+    public function toggleCrypto($socket, Deferred $deferred, $toggle, $method)
+    {
+        $error = null;
+        \set_error_handler(function ($_, $errstr) use (&$error) {
+            $error = \str_replace(array("\r", "\n"), ' ', $errstr);
+
+            // remove useless function name from error message
+            if (($pos = \strpos($error, "): ")) !== false) {
+                $error = \substr($error, $pos + 3);
+            }
+        });
+
+        $result = \stream_socket_enable_crypto($socket, $toggle, $method);
+
+        \restore_error_handler();
+
+        if (true === $result) {
+            $deferred->resolve(null);
+        } else if (false === $result) {
+            // overwrite callback arguments for PHP7+ only, so they do not show
+            // up in the Exception trace and do not cause a possible cyclic reference.
+            $d = $deferred;
+            $deferred = null;
+
+            if (\feof($socket) || $error === null) {
+                // EOF or failed without error => connection closed during handshake
+                $d->reject(new \UnexpectedValueException(
+                    'Connection lost during TLS handshake (ECONNRESET)',
+                    \defined('SOCKET_ECONNRESET') ? \SOCKET_ECONNRESET : 104
+                ));
+            } else {
+                // handshake failed with error message
+                $d->reject(new \UnexpectedValueException(
+                    $error
+                ));
+            }
+        } else {
+            // need more data, will retry
+        }
+    }
+}

package/vendor/react/socket/src/TcpConnector.php

@@ -0,0 +1,173 @@
+<?php
+
+namespace React\Socket;
+
+use React\EventLoop\Loop;
+use React\EventLoop\LoopInterface;
+use React\Promise;
+use InvalidArgumentException;
+use RuntimeException;
+
+final class TcpConnector implements ConnectorInterface
+{
+    private $loop;
+    private $context;
+
+    /**
+     * @param ?LoopInterface $loop
+     * @param array $context
+     */
+    public function __construct($loop = null, array $context = array())
+    {
+        if ($loop !== null && !$loop instanceof LoopInterface) { // manual type check to support legacy PHP < 7.1
+            throw new \InvalidArgumentException('Argument #1 ($loop) expected null|React\EventLoop\LoopInterface');
+        }
+
+        $this->loop = $loop ?: Loop::get();
+        $this->context = $context;
+    }
+
+    public function connect($uri)
+    {
+        if (\strpos($uri, '://') === false) {
+            $uri = 'tcp://' . $uri;
+        }
+
+        $parts = \parse_url($uri);
+        if (!$parts || !isset($parts['scheme'], $parts['host'], $parts['port']) || $parts['scheme'] !== 'tcp') {
+            return Promise\reject(new \InvalidArgumentException(
+                'Given URI "' . $uri . '" is invalid (EINVAL)',
+                \defined('SOCKET_EINVAL') ? \SOCKET_EINVAL : (\defined('PCNTL_EINVAL') ? \PCNTL_EINVAL : 22)
+            ));
+        }
+
+        $ip = \trim($parts['host'], '[]');
+        if (@\inet_pton($ip) === false) {
+            return Promise\reject(new \InvalidArgumentException(
+                'Given URI "' . $uri . '" does not contain a valid host IP (EINVAL)',
+                \defined('SOCKET_EINVAL') ? \SOCKET_EINVAL : (\defined('PCNTL_EINVAL') ? \PCNTL_EINVAL : 22)
+            ));
+        }
+
+        // use context given in constructor
+        $context = array(
+            'socket' => $this->context
+        );
+
+        // parse arguments from query component of URI
+        $args = array();
+        if (isset($parts['query'])) {
+            \parse_str($parts['query'], $args);
+        }
+
+        // If an original hostname has been given, use this for TLS setup.
+        // This can happen due to layers of nested connectors, such as a
+        // DnsConnector reporting its original hostname.
+        // These context options are here in case TLS is enabled later on this stream.
+        // If TLS is not enabled later, this doesn't hurt either.
+        if (isset($args['hostname'])) {
+            $context['ssl'] = array(
+                'SNI_enabled' => true,
+                'peer_name' => $args['hostname']
+            );
+
+            // Legacy PHP < 5.6 ignores peer_name and requires legacy context options instead.
+            // The SNI_server_name context option has to be set here during construction,
+            // as legacy PHP ignores any values set later.
+            // @codeCoverageIgnoreStart
+            if (\PHP_VERSION_ID < 50600) {
+                $context['ssl'] += array(
+                    'SNI_server_name' => $args['hostname'],
+                    'CN_match' => $args['hostname']
+                );
+            }
+            // @codeCoverageIgnoreEnd
+        }
+
+        // latest versions of PHP no longer accept any other URI components and
+        // HHVM fails to parse URIs with a query but no path, so let's simplify our URI here
+        $remote = 'tcp://' . $parts['host'] . ':' . $parts['port'];
+
+        $stream = @\stream_socket_client(
+            $remote,
+            $errno,
+            $errstr,
+            0,
+            \STREAM_CLIENT_CONNECT | \STREAM_CLIENT_ASYNC_CONNECT,
+            \stream_context_create($context)
+        );
+
+        if (false === $stream) {
+            return Promise\reject(new \RuntimeException(
+                'Connection to ' . $uri . ' failed: ' . $errstr . SocketServer::errconst($errno),
+                $errno
+            ));
+        }
+
+        // wait for connection
+        $loop = $this->loop;
+        return new Promise\Promise(function ($resolve, $reject) use ($loop, $stream, $uri) {
+            $loop->addWriteStream($stream, function ($stream) use ($loop, $resolve, $reject, $uri) {
+                $loop->removeWriteStream($stream);
+
+                // The following hack looks like the only way to
+                // detect connection refused errors with PHP's stream sockets.
+                if (false === \stream_socket_get_name($stream, true)) {
+                    // If we reach this point, we know the connection is dead, but we don't know the underlying error condition.
+                    // @codeCoverageIgnoreStart
+                    if (\function_exists('socket_import_stream')) {
+                        // actual socket errno and errstr can be retrieved with ext-sockets on PHP 5.4+
+                        $socket = \socket_import_stream($stream);
+                        $errno = \socket_get_option($socket, \SOL_SOCKET, \SO_ERROR);
+                        $errstr = \socket_strerror($errno);
+                    } elseif (\PHP_OS === 'Linux') {
+                        // Linux reports socket errno and errstr again when trying to write to the dead socket.
+                        // Suppress error reporting to get error message below and close dead socket before rejecting.
+                        // This is only known to work on Linux, Mac and Windows are known to not support this.
+                        $errno = 0;
+                        $errstr = '';
+                        \set_error_handler(function ($_, $error) use (&$errno, &$errstr) {
+                            // Match errstr from PHP's warning message.
+                            // fwrite(): send of 1 bytes failed with errno=111 Connection refused
+                            \preg_match('/errno=(\d+) (.+)/', $error, $m);
+                            $errno = isset($m[1]) ? (int) $m[1] : 0;
+                            $errstr = isset($m[2]) ? $m[2] : $error;
+                        });
+
+                        \fwrite($stream, \PHP_EOL);
+
+                        \restore_error_handler();
+                    } else {
+                        // Not on Linux and ext-sockets not available? Too bad.
+                        $errno = \defined('SOCKET_ECONNREFUSED') ? \SOCKET_ECONNREFUSED : 111;
+                        $errstr = 'Connection refused?';
+                    }
+                    // @codeCoverageIgnoreEnd
+
+                    \fclose($stream);
+                    $reject(new \RuntimeException(
+                        'Connection to ' . $uri . ' failed: ' . $errstr . SocketServer::errconst($errno),
+                        $errno
+                    ));
+                } else {
+                    $resolve(new Connection($stream, $loop));
+                }
+            });
+        }, function () use ($loop, $stream, $uri) {
+            $loop->removeWriteStream($stream);
+            \fclose($stream);
+
+            // @codeCoverageIgnoreStart
+            // legacy PHP 5.3 sometimes requires a second close call (see tests)
+            if (\PHP_VERSION_ID < 50400 && \is_resource($stream)) {
+                \fclose($stream);
+            }
+            // @codeCoverageIgnoreEnd
+
+            throw new \RuntimeException(
+                'Connection to ' . $uri . ' cancelled during TCP/IP handshake (ECONNABORTED)',
+                \defined('SOCKET_ECONNABORTED') ? \SOCKET_ECONNABORTED : 103
+            );
+        });
+    }
+}