nickpons666/sistema_funcionando_lastwar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Subir todo el proyecto incluyendo vendor y dependencias

Browse Source
This commit is contained in:
Admin
2026-01-16 20:33:13 -06:00
parent cf8ecfcf64
commit 0b3d76822d
2394 changed files with 2382358 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
vendor/ratchet/rfc6455/src/Handshake/ClientNegotiator.php vendored Executable file
View File

@@ -0,0 +1,68 @@
<?php
namespace Ratchet\RFC6455\Handshake;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\UriInterface;
use Psr\Http\Message\RequestFactoryInterface;
class ClientNegotiator {
private ResponseVerifier $verifier;
private RequestInterface $defaultHeader;
private RequestFactoryInterface $requestFactory;
public function __construct(
RequestFactoryInterface $requestFactory,
?PermessageDeflateOptions $perMessageDeflateOptions = null
) {
$this->verifier = new ResponseVerifier;
$this->requestFactory = $requestFactory;
$this->defaultHeader = $this->requestFactory
->createRequest('GET', '')
->withHeader('Connection' , 'Upgrade')
->withHeader('Upgrade' , 'websocket')
->withHeader('Sec-WebSocket-Version', $this->getVersion())
->withHeader('User-Agent' , 'Ratchet');
$perMessageDeflateOptions ??= PermessageDeflateOptions::createDisabled();
// https://bugs.php.net/bug.php?id=73373
// https://bugs.php.net/bug.php?id=74240 - need >=7.1.4 or >=7.0.18
if ($perMessageDeflateOptions->isEnabled() && !PermessageDeflateOptions::permessageDeflateSupported()) {
trigger_error('permessage-deflate is being disabled because it is not supported by your PHP version.', E_USER_NOTICE);
$perMessageDeflateOptions = PermessageDeflateOptions::createDisabled();
}
if ($perMessageDeflateOptions->isEnabled() && !function_exists('deflate_add')) {
trigger_error('permessage-deflate is being disabled because you do not have the zlib extension.', E_USER_NOTICE);
$perMessageDeflateOptions = PermessageDeflateOptions::createDisabled();
}
$this->defaultHeader = $perMessageDeflateOptions->addHeaderToRequest($this->defaultHeader);
}
public function generateRequest(UriInterface $uri): RequestInterface {
return $this->defaultHeader->withUri($uri)
->withHeader('Sec-WebSocket-Key', $this->generateKey());
}
public function validateResponse(RequestInterface $request, ResponseInterface $response): bool {
return $this->verifier->verifyAll($request, $response);
}
public function generateKey(): string {
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwzyz1234567890+/=';
$charRange = strlen($chars) - 1;
$key = '';
for ($i = 0; $i < 16; $i++) {
$key .= $chars[mt_rand(0, $charRange)];
}
return base64_encode($key);
}
public function getVersion(): int {
return 13;
}
}

7
vendor/ratchet/rfc6455/src/Handshake/InvalidPermessageDeflateOptionsException.php vendored Executable file
View File

@@ -0,0 +1,7 @@
<?php
namespace Ratchet\RFC6455\Handshake;
class InvalidPermessageDeflateOptionsException extends \Exception
{
}

48
vendor/ratchet/rfc6455/src/Handshake/NegotiatorInterface.php vendored Executable file
View File

@@ -0,0 +1,48 @@
<?php
namespace Ratchet\RFC6455\Handshake;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
/**
* A standard interface for interacting with the various version of the WebSocket protocol
* @todo Look in to extension support
*/
interface NegotiatorInterface {
const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
/**
* Given an HTTP header, determine if this version should handle the protocol
* @param RequestInterface $request
* @return bool
*/
public function isProtocol(RequestInterface $request): bool;
/**
* Although the version has a name associated with it the integer returned is the proper identification
* @return int
*/
public function getVersionNumber(): int;
/**
* Perform the handshake and return the response headers
* @param RequestInterface $request
* @return ResponseInterface
*/
public function handshake(RequestInterface $request): ResponseInterface;
/**
* Add supported protocols. If the request has any matching the response will include one
* @param array $protocols
*/
public function setSupportedSubProtocols(array $protocols): void;
/**
* If enabled and support for a subprotocol has been added handshake
* will not upgrade if a match between request and supported subprotocols
* @param boolean $enable
* @todo Consider extending this interface and moving this there.
* The spec does say the server can fail for this reason, but
* it is not a requirement. This is an implementation detail.
*/
public function setStrictSubProtocolCheck(bool $enable): void;
}

269
vendor/ratchet/rfc6455/src/Handshake/PermessageDeflateOptions.php vendored Executable file
View File

@@ -0,0 +1,269 @@
<?php
namespace Ratchet\RFC6455\Handshake;
use Psr\Http\Message\MessageInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
final class PermessageDeflateOptions
{
public const MAX_WINDOW_BITS = 15;
private const VALID_BITS = [8, 9, 10, 11, 12, 13, 14, 15];
private bool $deflateEnabled = false;
private ?bool $server_no_context_takeover = null;
private ?bool $client_no_context_takeover = null;
private ?int $server_max_window_bits = null;
private ?int $client_max_window_bits = null;
private function __construct() { }
public static function createEnabled() {
$new = new self();
$new->deflateEnabled = true;
$new->client_max_window_bits = self::MAX_WINDOW_BITS;
$new->client_no_context_takeover = false;
$new->server_max_window_bits = self::MAX_WINDOW_BITS;
$new->server_no_context_takeover = false;
return $new;
}
public static function createDisabled() {
return new self();
}
public function withClientNoContextTakeover(): self {
$new = clone $this;
$new->client_no_context_takeover = true;
return $new;
}
public function withoutClientNoContextTakeover(): self {
$new = clone $this;
$new->client_no_context_takeover = false;
return $new;
}
public function withServerNoContextTakeover(): self {
$new = clone $this;
$new->server_no_context_takeover = true;
return $new;
}
public function withoutServerNoContextTakeover(): self {
$new = clone $this;
$new->server_no_context_takeover = false;
return $new;
}
public function withServerMaxWindowBits(int $bits = self::MAX_WINDOW_BITS): self {
if (!in_array($bits, self::VALID_BITS)) {
throw new \Exception('server_max_window_bits must have a value between 8 and 15.');
}
$new = clone $this;
$new->server_max_window_bits = $bits;
return $new;
}
public function withClientMaxWindowBits(int $bits = self::MAX_WINDOW_BITS): self {
if (!in_array($bits, self::VALID_BITS)) {
throw new \Exception('client_max_window_bits must have a value between 8 and 15.');
}
$new = clone $this;
$new->client_max_window_bits = $bits;
return $new;
}
/**
* https://tools.ietf.org/html/rfc6455#section-9.1
* https://tools.ietf.org/html/rfc7692#section-7
*
* @param MessageInterface $requestOrResponse
* @return PermessageDeflateOptions[]
* @throws \Exception
*/
public static function fromRequestOrResponse(MessageInterface $requestOrResponse): array {
$optionSets = [];
$extHeader = preg_replace('/\s+/', '', join(', ', $requestOrResponse->getHeader('Sec-Websocket-Extensions')));
$configurationRequests = explode(',', $extHeader);
foreach ($configurationRequests as $configurationRequest) {
$parts = explode(';', $configurationRequest);
if (count($parts) == 0) {
continue;
}
if ($parts[0] !== 'permessage-deflate') {
continue;
}
array_shift($parts);
$options = new self();
$options->deflateEnabled = true;
foreach ($parts as $part) {
$kv = explode('=', $part);
$key = $kv[0];
$value = count($kv) > 1 ? $kv[1] : null;
switch ($key) {
case "server_no_context_takeover":
case "client_no_context_takeover":
if ($value !== null) {
throw new InvalidPermessageDeflateOptionsException($key . ' must not have a value.');
}
$value = true;
break;
case "server_max_window_bits":
$value = (int) $value;
if (!in_array($value, self::VALID_BITS)) {
throw new InvalidPermessageDeflateOptionsException($key . ' must have a value between 8 and 15.');
}
break;
case "client_max_window_bits":
if ($value === null) {
$value = 15;
} else {
$value = (int) $value;
}
if (!in_array($value, self::VALID_BITS)) {
throw new InvalidPermessageDeflateOptionsException($key . ' must have no value or a value between 8 and 15.');
}
break;
default:
throw new InvalidPermessageDeflateOptionsException('Option "' . $key . '"is not valid for permessage deflate');
}
if ($options->$key !== null) {
throw new InvalidPermessageDeflateOptionsException($key . ' specified more than once. Connection must be declined.');
}
$options->$key = $value;
}
if ($options->getClientMaxWindowBits() === null) {
$options->client_max_window_bits = 15;
}
if ($options->getServerMaxWindowBits() === null) {
$options->server_max_window_bits = 15;
}
$optionSets[] = $options;
}
// always put a disabled on the end
$optionSets[] = new self();
return $optionSets;
}
/**
* @return bool|null
*/
public function getServerNoContextTakeover(): ?bool
{
return $this->server_no_context_takeover;
}
/**
* @return bool|null
*/
public function getClientNoContextTakeover(): ?bool
{
return $this->client_no_context_takeover;
}
/**
* @return int|null
*/
public function getServerMaxWindowBits(): ?int
{
return $this->server_max_window_bits;
}
/**
* @return int|null
*/
public function getClientMaxWindowBits(): ?int
{
return $this->client_max_window_bits;
}
/**
* @return bool
*/
public function isEnabled(): bool
{
return $this->deflateEnabled;
}
/**
* @param ResponseInterface $response
* @return ResponseInterface
*/
public function addHeaderToResponse(ResponseInterface $response): ResponseInterface
{
if (!$this->deflateEnabled) {
return $response;
}
$header = 'permessage-deflate';
if ($this->client_max_window_bits != 15) {
$header .= '; client_max_window_bits='. $this->client_max_window_bits;
}
if ($this->client_no_context_takeover) {
$header .= '; client_no_context_takeover';
}
if ($this->server_max_window_bits != 15) {
$header .= '; server_max_window_bits=' . $this->server_max_window_bits;
}
if ($this->server_no_context_takeover) {
$header .= '; server_no_context_takeover';
}
return $response->withAddedHeader('Sec-Websocket-Extensions', $header);
}
public function addHeaderToRequest(RequestInterface $request): RequestInterface {
if (!$this->deflateEnabled) {
return $request;
}
$header = 'permessage-deflate';
if ($this->server_no_context_takeover) {
$header .= '; server_no_context_takeover';
}
if ($this->client_no_context_takeover) {
$header .= '; client_no_context_takeover';
}
if ($this->server_max_window_bits != 15) {
$header .= '; server_max_window_bits=' . $this->server_max_window_bits;
}
$header .= '; client_max_window_bits';
if ($this->client_max_window_bits != 15) {
$header .= '='. $this->client_max_window_bits;
}
return $request->withAddedHeader('Sec-Websocket-Extensions', $header);
}
public static function permessageDeflateSupported(string $version = PHP_VERSION): bool {
if (!function_exists('deflate_init')) {
return false;
}
if (version_compare($version, '7.1.3', '>')) {
return true;
}
if (version_compare($version, '7.0.18', '>=')
&& version_compare($version, '7.1.0', '<')) {
return true;
}
return false;
}
}

161
vendor/ratchet/rfc6455/src/Handshake/RequestVerifier.php vendored Executable file
View File

@@ -0,0 +1,161 @@
<?php
namespace Ratchet\RFC6455\Handshake;
use Psr\Http\Message\RequestInterface;
/**
* These are checks to ensure the client requested handshake are valid
* Verification rules come from section 4.2.1 of the RFC6455 document
* @todo Currently just returning invalid - should consider returning appropriate HTTP status code error #s
*/
class RequestVerifier {
public const VERSION = 13;
/**
* Given an array of the headers this method will run through all verification methods
* @param RequestInterface $request
* @return bool TRUE if all headers are valid, FALSE if 1 or more were invalid
*/
public function verifyAll(RequestInterface $request): bool {
$passes = 0;
$passes += (int)$this->verifyMethod($request->getMethod());
$passes += (int)$this->verifyHTTPVersion($request->getProtocolVersion());
$passes += (int)$this->verifyRequestURI($request->getUri()->getPath());
$passes += (int)$this->verifyHost($request->getHeader('Host'));
$passes += (int)$this->verifyUpgradeRequest($request->getHeader('Upgrade'));
$passes += (int)$this->verifyConnection($request->getHeader('Connection'));
$passes += (int)$this->verifyKey($request->getHeader('Sec-WebSocket-Key'));
$passes += (int)$this->verifyVersion($request->getHeader('Sec-WebSocket-Version'));
return 8 === $passes;
}
/**
* Test the HTTP method. MUST be "GET"
* @param string
* @return bool
*/
public function verifyMethod(string $val): bool {
return 'get' === strtolower($val);
}
/**
* Test the HTTP version passed. MUST be 1.1 or greater
* @param string|int
* @return bool
*/
public function verifyHTTPVersion($val): bool {
return 1.1 <= (double)$val;
}
/**
* @param string
* @return bool
*/
public function verifyRequestURI(string $val): bool {
if ($val[0] !== '/') {
return false;
}
if (false !== strstr($val, '#')) {
return false;
}
if (!extension_loaded('mbstring')) {
return true;
}
return mb_check_encoding($val, 'US-ASCII');
}
/**
* @param array $hostHeader
* @return bool
* @todo Once I fix HTTP::getHeaders just verify this isn't NULL or empty...or maybe need to verify it's a valid domain??? Or should it equal $_SERVER['HOST'] ?
*/
public function verifyHost(array $hostHeader): bool {
return 1 === count($hostHeader);
}
/**
* Verify the Upgrade request to WebSockets.
* @param array $upgradeHeader MUST equal "websocket"
* @return bool
*/
public function verifyUpgradeRequest(array $upgradeHeader): bool {
return 1 === count($upgradeHeader) && 'websocket' === strtolower($upgradeHeader[0]);
}
/**
* Verify the Connection header
* @param array $connectionHeader MUST include "Upgrade"
* @return bool
*/
public function verifyConnection(array $connectionHeader): bool {
foreach ($connectionHeader as $l) {
$upgrades = array_filter(
array_map('trim', array_map('strtolower', explode(',', $l))),
static fn (string $x) => 'upgrade' === $x
);
if (count($upgrades) > 0) {
return true;
}
}
return false;
}
/**
* This function verifies the nonce is valid (64 big encoded, 16 bytes random string)
* @param array $keyHeader
* @return bool
* @todo The spec says we don't need to base64_decode - can I just check if the length is 24 and not decode?
* @todo Check the spec to see what the encoding of the key could be
*/
public function verifyKey(array $keyHeader): bool {
return 1 === count($keyHeader) && 16 === strlen(base64_decode($keyHeader[0]));
}
/**
* Verify the version passed matches this RFC
* @param string[] $versionHeader MUST equal ["13"]
* @return bool
*/
public function verifyVersion(array $versionHeader): bool {
return 1 === count($versionHeader) && static::VERSION === (int)$versionHeader[0];
}
/**
* @todo Write logic for this method. See section 4.2.1.8
*/
public function verifyProtocol($val): bool {
return true;
}
/**
* @todo Write logic for this method. See section 4.2.1.9
*/
public function verifyExtensions($val): bool {
return true;
}
public function getPermessageDeflateOptions(array $requestHeader, array $responseHeader): array {
$headerChecker = static fn (string $val) => 'permessage-deflate' === substr($val, 0, strlen('permessage-deflate'));
$deflate = true;
if (!isset($requestHeader['Sec-WebSocket-Extensions']) || count(array_filter($requestHeader['Sec-WebSocket-Extensions'], $headerChecker)) === 0) {
$deflate = false;
}
if (!isset($responseHeader['Sec-WebSocket-Extensions']) || count(array_filter($responseHeader['Sec-WebSocket-Extensions'], $headerChecker)) === 0) {
$deflate = false;
}
return [
'deflate' => $deflate,
'no_context_takeover' => false,
'max_window_bits' => null,
'request_no_context_takeover' => false,
'request_max_window_bits' => null
];
}
}

70
vendor/ratchet/rfc6455/src/Handshake/ResponseVerifier.php vendored Executable file
View File

@@ -0,0 +1,70 @@
<?php
namespace Ratchet\RFC6455\Handshake;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
class ResponseVerifier {
public function verifyAll(RequestInterface $request, ResponseInterface $response): bool {
$passes = 0;
$passes += (int)$this->verifyStatus($response->getStatusCode());
$passes += (int)$this->verifyUpgrade($response->getHeader('Upgrade'));
$passes += (int)$this->verifyConnection($response->getHeader('Connection'));
$passes += (int)$this->verifySecWebSocketAccept(
$response->getHeader('Sec-WebSocket-Accept')
, $request->getHeader('Sec-WebSocket-Key')
);
$passes += (int)$this->verifySubProtocol(
$request->getHeader('Sec-WebSocket-Protocol')
, $response->getHeader('Sec-WebSocket-Protocol')
);
$passes += (int)$this->verifyExtensions(
$request->getHeader('Sec-WebSocket-Extensions')
, $response->getHeader('Sec-WebSocket-Extensions')
);
return (6 === $passes);
}
public function verifyStatus(int $status): bool {
return $status === 101;
}
public function verifyUpgrade(array $upgrade): bool {
return in_array('websocket', array_map('strtolower', $upgrade));
}
public function verifyConnection(array $connection): bool {
return in_array('upgrade', array_map('strtolower', $connection));
}
public function verifySecWebSocketAccept(array $swa, array $key): bool {
return
1 === count($swa) &&
1 === count($key) &&
$swa[0] === $this->sign($key[0])
;
}
public function sign(string $key): string {
return base64_encode(sha1($key . NegotiatorInterface::GUID, true));
}
public function verifySubProtocol(array $requestHeader, array $responseHeader): bool {
if (0 === count($responseHeader)) {
return true;
}
$requestedProtocols = array_map('trim', explode(',', implode(',', $requestHeader)));
return count($responseHeader) === 1 && count(array_intersect($responseHeader, $requestedProtocols)) === 1;
}
public function verifyExtensions(array $requestHeader, array $responseHeader): int {
if (in_array('permessage-deflate', $responseHeader)) {
return strpos(implode(',', $requestHeader), 'permessage-deflate') !== false ? 1 : 0;
}
return 1;
}
}

168
vendor/ratchet/rfc6455/src/Handshake/ServerNegotiator.php vendored Executable file
View File

@@ -0,0 +1,168 @@
<?php
namespace Ratchet\RFC6455\Handshake;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use GuzzleHttp\Psr7\Response;
use Psr\Http\Message\ResponseInterface;
/**
* The latest version of the WebSocket protocol
* @todo Unicode: return mb_convert_encoding(pack("N",$u), mb_internal_encoding(), 'UCS-4BE');
*/
class ServerNegotiator implements NegotiatorInterface {
private RequestVerifier $verifier;
private ResponseFactoryInterface $responseFactory;
private array $_supportedSubProtocols = [];
private bool $_strictSubProtocols = false;
private bool $enablePerMessageDeflate = false;
public function __construct(
RequestVerifier $requestVerifier,
ResponseFactoryInterface $responseFactory,
$enablePerMessageDeflate = false
) {
$this->verifier = $requestVerifier;
$this->responseFactory = $responseFactory;
// https://bugs.php.net/bug.php?id=73373
// https://bugs.php.net/bug.php?id=74240 - need >=7.1.4 or >=7.0.18
$supported = PermessageDeflateOptions::permessageDeflateSupported();
if ($enablePerMessageDeflate && !$supported) {
throw new \Exception('permessage-deflate is not supported by your PHP version (need >=7.1.4 or >=7.0.18).');
}
if ($enablePerMessageDeflate && !function_exists('deflate_add')) {
throw new \Exception('permessage-deflate is not supported because you do not have the zlib extension.');
}
$this->enablePerMessageDeflate = $enablePerMessageDeflate;
}
/**
* {@inheritdoc}
*/
public function isProtocol(RequestInterface $request): bool {
return $this->verifier->verifyVersion($request->getHeader('Sec-WebSocket-Version'));
}
/**
* {@inheritdoc}
*/
public function getVersionNumber(): int {
return RequestVerifier::VERSION;
}
/**
* {@inheritdoc}
*/
public function handshake(RequestInterface $request): ResponseInterface {
$response = $this->responseFactory->createResponse();
if (true !== $this->verifier->verifyMethod($request->getMethod())) {
return $response->withHeader('Allow', 'GET')->withStatus(405);
}
if (true !== $this->verifier->verifyHTTPVersion($request->getProtocolVersion())) {
return $response->withStatus(505);
}
if (true !== $this->verifier->verifyRequestURI($request->getUri()->getPath())) {
return $response->withStatus(400);
}
if (true !== $this->verifier->verifyHost($request->getHeader('Host'))) {
return $response->withStatus(400);
}
$upgradeResponse = $response
->withHeader('Connection' , 'Upgrade')
->withHeader('Upgrade' , 'websocket')
->withHeader('Sec-WebSocket-Version', $this->getVersionNumber());
if (count($this->_supportedSubProtocols) > 0) {
$upgradeResponse = $upgradeResponse->withHeader(
'Sec-WebSocket-Protocol', implode(', ', array_keys($this->_supportedSubProtocols))
);
}
if (true !== $this->verifier->verifyUpgradeRequest($request->getHeader('Upgrade'))) {
return $upgradeResponse->withStatus(426, 'Upgrade header MUST be provided');
}
if (true !== $this->verifier->verifyConnection($request->getHeader('Connection'))) {
return $response->withStatus(400, 'Connection Upgrade MUST be requested');
}
if (true !== $this->verifier->verifyKey($request->getHeader('Sec-WebSocket-Key'))) {
return $response->withStatus(400, 'Invalid Sec-WebSocket-Key');
}
if (true !== $this->verifier->verifyVersion($request->getHeader('Sec-WebSocket-Version'))) {
return $upgradeResponse->withStatus(426);
}
$subProtocols = $request->getHeader('Sec-WebSocket-Protocol');
if (count($subProtocols) > 0 || (count($this->_supportedSubProtocols) > 0 && $this->_strictSubProtocols)) {
$subProtocols = array_map('trim', explode(',', implode(',', $subProtocols)));
$match = array_reduce($subProtocols, fn ($accumulator, $protocol) => $accumulator ?: (isset($this->_supportedSubProtocols[$protocol]) ? $protocol : null), null);
if ($this->_strictSubProtocols && null === $match) {
return $upgradeResponse->withStatus(426, 'No Sec-WebSocket-Protocols requested supported');
}
if (null !== $match) {
$response = $response->withHeader('Sec-WebSocket-Protocol', $match);
}
}
$response = $response
->withStatus(101)
->withHeader('Upgrade' , 'websocket')
->withHeader('Connection' , 'Upgrade')
->withHeader('Sec-WebSocket-Accept', $this->sign((string)$request->getHeader('Sec-WebSocket-Key')[0]))
->withHeader('X-Powered-By' , 'Ratchet');
try {
$perMessageDeflateRequest = PermessageDeflateOptions::fromRequestOrResponse($request)[0];
} catch (InvalidPermessageDeflateOptionsException $e) {
return new Response(400, [], null, '1.1', $e->getMessage());
}
if ($this->enablePerMessageDeflate && $perMessageDeflateRequest->isEnabled()) {
$response = $perMessageDeflateRequest->addHeaderToResponse($response);
}
return $response;
}
/**
* Used when doing the handshake to encode the key, verifying client/server are speaking the same language
* @param string $key
* @return string
* @internal
*/
public function sign(string $key): string {
return base64_encode(sha1($key . static::GUID, true));
}
/**
* @param array $protocols
*/
public function setSupportedSubProtocols(array $protocols): void {
$this->_supportedSubProtocols = array_flip($protocols);
}
/**
* If enabled and support for a subprotocol has been added handshake
* will not upgrade if a match between request and supported subprotocols
* @param boolean $enable
* @todo Consider extending this interface and moving this there.
* The spec does say the server can fail for this reason, but
* it is not a requirement. This is an implementation detail.
*/
public function setStrictSubProtocolCheck(bool $enable): void {
$this->_strictSubProtocols = $enable;
}
}

20
vendor/ratchet/rfc6455/src/Messaging/CloseFrameChecker.php vendored Executable file
View File

@@ -0,0 +1,20 @@
<?php
namespace Ratchet\RFC6455\Messaging;
class CloseFrameChecker {
private array $validCloseCodes = [
Frame::CLOSE_NORMAL,
Frame::CLOSE_GOING_AWAY,
Frame::CLOSE_PROTOCOL,
Frame::CLOSE_BAD_DATA,
Frame::CLOSE_BAD_PAYLOAD,
Frame::CLOSE_POLICY,
Frame::CLOSE_TOO_BIG,
Frame::CLOSE_MAND_EXT,
Frame::CLOSE_SRV_ERR,
];
public function __invoke(int $val): bool {
return ($val >= 3000 && $val <= 4999) || in_array($val, $this->validCloseCodes);
}
}

28
vendor/ratchet/rfc6455/src/Messaging/DataInterface.php vendored Executable file
View File

@@ -0,0 +1,28 @@
<?php
namespace Ratchet\RFC6455\Messaging;
interface DataInterface extends \Stringable {
/**
* Determine if the message is complete or still fragmented
* @return bool
*/
public function isCoalesced(): bool;
/**
* Get the number of bytes the payload is set to be
* @return int
*/
public function getPayloadLength(): int;
/**
* Get the payload (message) sent from peer
* @return string
*/
public function getPayload(): string;
/**
* Get raw contents of the message
* @return string
*/
public function getContents(): string;
}

473
vendor/ratchet/rfc6455/src/Messaging/Frame.php vendored Executable file
View File

@@ -0,0 +1,473 @@
<?php
namespace Ratchet\RFC6455\Messaging;
class Frame implements FrameInterface {
const OP_CONTINUE = 0;
const OP_TEXT = 1;
const OP_BINARY = 2;
const OP_CLOSE = 8;
const OP_PING = 9;
const OP_PONG = 10;
const CLOSE_NORMAL = 1000;
const CLOSE_GOING_AWAY = 1001;
const CLOSE_PROTOCOL = 1002;
const CLOSE_BAD_DATA = 1003;
const CLOSE_NO_STATUS = 1005;
const CLOSE_ABNORMAL = 1006;
const CLOSE_BAD_PAYLOAD = 1007;
const CLOSE_POLICY = 1008;
const CLOSE_TOO_BIG = 1009;
const CLOSE_MAND_EXT = 1010;
const CLOSE_SRV_ERR = 1011;
const CLOSE_TLS = 1015;
const MASK_LENGTH = 4;
/**
* The contents of the frame
*/
protected string $data = '';
/**
* Number of bytes received from the frame
*/
public int $bytesRecvd = 0;
/**
* Number of bytes in the payload (as per framing protocol)
*/
protected int $defPayLen = -1;
/**
* If the frame is coalesced this is true
* This is to prevent doing math every time ::isCoalesced is called
*/
private bool $isCoalesced = false;
/**
* The unpacked first byte of the frame
*/
protected int $firstByte = -1;
/**
* The unpacked second byte of the frame
*/
protected int $secondByte = -1;
/**
* @var callable
* @returns \UnderflowException
*/
private $ufeg;
/**
* @param string|null $payload
* @param bool $final
* @param int $opcode
* @param callable<\UnderflowException> $ufExceptionFactory
*/
public function __construct(?string $payload = null, bool $final = true, int $opcode = 1, ?callable $ufExceptionFactory = null) {
$this->ufeg = $ufExceptionFactory ?: static fn (string $msg = '') => new \UnderflowException($msg);
if (null === $payload) {
return;
}
$this->defPayLen = strlen($payload);
$this->firstByte = ($final ? 128 : 0) + $opcode;
$this->secondByte = $this->defPayLen;
$this->isCoalesced = true;
$ext = '';
if ($this->defPayLen > 65535) {
$ext = pack('NN', 0, $this->defPayLen);
$this->secondByte = 127;
} elseif ($this->defPayLen > 125) {
$ext = pack('n', $this->defPayLen);
$this->secondByte = 126;
}
$this->data = chr($this->firstByte) . chr($this->secondByte) . $ext . $payload;
$this->bytesRecvd = 2 + strlen($ext) + $this->defPayLen;
}
/**
* {@inheritdoc}
*/
public function isCoalesced(): bool {
if (true === $this->isCoalesced) {
return true;
}
try {
$payload_length = $this->getPayloadLength();
$payload_start = $this->getPayloadStartingByte();
} catch (\UnderflowException $e) {
return false;
}
$this->isCoalesced = $this->bytesRecvd >= $payload_length + $payload_start;
return $this->isCoalesced;
}
/**
* {@inheritdoc}
*/
public function addBuffer(string $buf): void {
$len = strlen($buf);
$this->data .= $buf;
$this->bytesRecvd += $len;
if ($this->firstByte === -1 && $this->bytesRecvd !== 0) {
$this->firstByte = ord($this->data[0]);
}
if ($this->secondByte === -1 && $this->bytesRecvd >= 2) {
$this->secondByte = ord($this->data[1]);
}
}
/**
* {@inheritdoc}
*/
public function isFinal(): bool {
if (-1 === $this->firstByte) {
throw call_user_func($this->ufeg, 'Not enough bytes received to determine if this is the final frame in message');
}
return 128 === ($this->firstByte & 128);
}
public function setRsv1(bool $value = true): self {
if (strlen($this->data) == 0) {
throw new \UnderflowException("Cannot set Rsv1 because there is no data.");
}
$this->firstByte =
($this->isFinal() ? 128 : 0)
+ $this->getOpcode()
+ ($value ? 64 : 0)
+ ($this->getRsv2() ? 32 : 0)
+ ($this->getRsv3() ? 16 : 0)
;
$this->data[0] = chr($this->firstByte);
return $this;
}
/**
* @return boolean
* @throws \UnderflowException
*/
public function getRsv1(): bool {
if (-1 === $this->firstByte) {
throw call_user_func($this->ufeg, 'Not enough bytes received to determine reserved bit');
}
return 64 === ($this->firstByte & 64);
}
/**
* @return boolean
* @throws \UnderflowException
*/
public function getRsv2(): bool {
if (-1 === $this->firstByte) {
throw call_user_func($this->ufeg, 'Not enough bytes received to determine reserved bit');
}
return 32 === ($this->firstByte & 32);
}
/**
* @return boolean
* @throws \UnderflowException
*/
public function getRsv3(): bool {
if (-1 === $this->firstByte) {
throw call_user_func($this->ufeg, 'Not enough bytes received to determine reserved bit');
}
return 16 === ($this->firstByte & 16);
}
/**
* {@inheritdoc}
*/
public function isMasked(): bool {
if (-1 === $this->secondByte) {
throw call_user_func($this->ufeg, "Not enough bytes received ({$this->bytesRecvd}) to determine if mask is set");
}
return 128 === ($this->secondByte & 128);
}
/**
* {@inheritdoc}
*/
public function getMaskingKey(): string {
if (!$this->isMasked()) {
return '';
}
$start = 1 + $this->getNumPayloadBytes();
if ($this->bytesRecvd < $start + static::MASK_LENGTH) {
throw call_user_func($this->ufeg, 'Not enough data buffered to calculate the masking key');
}
return substr($this->data, $start, static::MASK_LENGTH);
}
/**
* Create a 4 byte masking key
* @return string
*/
public function generateMaskingKey(): string {
$mask = '';
for ($i = 1; $i <= static::MASK_LENGTH; $i++) {
$mask .= chr(rand(32, 126));
}
return $mask;
}
/**
* Apply a mask to the payload
* @param string|null If NULL is passed a masking key will be generated
* @throws \OutOfBoundsException
* @throws \InvalidArgumentException If there is an issue with the given masking key
* @return Frame
*/
public function maskPayload(?string $maskingKey = null): self {
if (null === $maskingKey) {
$maskingKey = $this->generateMaskingKey();
}
if (static::MASK_LENGTH !== strlen($maskingKey)) {
throw new \InvalidArgumentException("Masking key must be " . static::MASK_LENGTH ." characters");
}
if (extension_loaded('mbstring') && true !== mb_check_encoding($maskingKey, 'US-ASCII')) {
throw new \OutOfBoundsException("Masking key MUST be ASCII");
}
$this->unMaskPayload();
$this->secondByte = $this->secondByte | 128;
$this->data[1] = chr($this->secondByte);
$this->data = substr_replace($this->data, $maskingKey, $this->getNumPayloadBytes() + 1, 0);
$this->bytesRecvd += static::MASK_LENGTH;
$this->data = substr_replace($this->data, $this->applyMask($maskingKey), $this->getPayloadStartingByte(), $this->getPayloadLength());
return $this;
}
/**
* Remove a mask from the payload
* @throws \UnderFlowException If the frame is not coalesced
* @return Frame
*/
public function unMaskPayload(): self {
if (!$this->isCoalesced()) {
throw call_user_func($this->ufeg, 'Frame must be coalesced before applying mask');
}
if (!$this->isMasked()) {
return $this;
}
$maskingKey = $this->getMaskingKey();
$this->secondByte = $this->secondByte & ~128;
$this->data[1] = chr($this->secondByte);
$this->data = substr_replace($this->data, '', $this->getNumPayloadBytes() + 1, static::MASK_LENGTH);
$this->bytesRecvd -= static::MASK_LENGTH;
$this->data = substr_replace($this->data, $this->applyMask($maskingKey), $this->getPayloadStartingByte(), $this->getPayloadLength());
return $this;
}
/**
* Apply a mask to a string or the payload of the instance
* @param string $maskingKey The 4 character masking key to be applied
* @param string|null $payload A string to mask or null to use the payload
* @throws \UnderflowException If using the payload but enough hasn't been buffered
* @return string The masked string
*/
public function applyMask(string $maskingKey, ?string $payload = null): string {
if (null === $payload) {
if (!$this->isCoalesced()) {
throw call_user_func($this->ufeg, 'Frame must be coalesced to apply a mask');
}
$payload = substr($this->data, $this->getPayloadStartingByte(), $this->getPayloadLength());
}
$len = strlen($payload);
if (0 === $len) {
return '';
}
return $payload ^ str_pad('', $len, $maskingKey, STR_PAD_RIGHT);
}
/**
* {@inheritdoc}
*/
public function getOpcode(): int {
if (-1 === $this->firstByte) {
throw call_user_func($this->ufeg, 'Not enough bytes received to determine opcode');
}
return ($this->firstByte & ~240);
}
/**
* Gets the decimal value of bits 9 (10th) through 15 inclusive
* @return int
* @throws \UnderflowException If the buffer doesn't have enough data to determine this
*/
protected function getFirstPayloadVal(): int {
if (-1 === $this->secondByte) {
throw call_user_func($this->ufeg, 'Not enough bytes received');
}
return $this->secondByte & 127;
}
/**
* @return int (7|23|71) Number of bits defined for the payload length in the fame
* @throws \UnderflowException
*/
protected function getNumPayloadBits(): int {
if (-1 === $this->secondByte) {
throw call_user_func($this->ufeg, 'Not enough bytes received');
}
// By default 7 bits are used to describe the payload length
// These are bits 9 (10th) through 15 inclusive
$bits = 7;
// Get the value of those bits
$check = $this->getFirstPayloadVal();
// If the value is 126 the 7 bits plus the next 16 are used to describe the payload length
if ($check >= 126) {
$bits += 16;
}
// If the value of the initial payload length are is 127 an additional 48 bits are used to describe length
// Note: The documentation specifies the length is to be 63 bits, but I think that's a typo and is 64 (16+48)
if ($check === 127) {
$bits += 48;
}
return $bits;
}
/**
* This just returns the number of bytes used in the frame to describe the payload length (as opposed to # of bits)
* @see getNumPayloadBits
*/
protected function getNumPayloadBytes(): int {
return (1 + $this->getNumPayloadBits()) / 8;
}
/**
* {@inheritdoc}
*/
public function getPayloadLength(): int {
if ($this->defPayLen !== -1) {
return $this->defPayLen;
}
$this->defPayLen = $this->getFirstPayloadVal();
if ($this->defPayLen <= 125) {
return $this->getPayloadLength();
}
$byte_length = $this->getNumPayloadBytes();
if ($this->bytesRecvd < 1 + $byte_length) {
$this->defPayLen = -1;
throw call_user_func($this->ufeg, 'Not enough data buffered to determine payload length');
}
$len = 0;
for ($i = 2; $i <= $byte_length; $i++) {
$len <<= 8;
$len += ord($this->data[$i]);
}
$this->defPayLen = $len;
return $this->getPayloadLength();
}
/**
* {@inheritdoc}
*/
public function getPayloadStartingByte(): int {
return 1 + $this->getNumPayloadBytes() + ($this->isMasked() ? static::MASK_LENGTH : 0);
}
/**
* {@inheritdoc}
* @todo Consider not checking mask, always returning the payload, masked or not
*/
public function getPayload(): string {
if (!$this->isCoalesced()) {
throw call_user_func($this->ufeg, 'Can not return partial message');
}
return $this->__toString();
}
/**
* Get the raw contents of the frame
* @todo This is untested, make sure the substr is right - trying to return the frame w/o the overflow
*/
public function getContents(): string {
return substr($this->data, 0, $this->getPayloadStartingByte() + $this->getPayloadLength());
}
public function __toString(): string {
$payload = (string)substr($this->data, $this->getPayloadStartingByte(), $this->getPayloadLength());
if ($this->isMasked()) {
$payload = $this->applyMask($this->getMaskingKey(), $payload);
}
return $payload;
}
/**
* Sometimes clients will concatenate more than one frame over the wire
* This method will take the extra bytes off the end and return them
* @return string
*/
public function extractOverflow(): string {
if ($this->isCoalesced()) {
$endPoint = $this->getPayloadLength();
$endPoint += $this->getPayloadStartingByte();
if ($this->bytesRecvd > $endPoint) {
$overflow = substr($this->data, $endPoint);
$this->data = substr($this->data, 0, $endPoint);
return $overflow;
}
}
return '';
}
}

38
vendor/ratchet/rfc6455/src/Messaging/FrameInterface.php vendored Executable file
View File

@@ -0,0 +1,38 @@
<?php
namespace Ratchet\RFC6455\Messaging;
interface FrameInterface extends DataInterface {
/**
* Add incoming data to the frame from peer
* @param string
*/
public function addBuffer(string $buf): void;
/**
* Is this the final frame in a fragmented message?
* @return bool
*/
public function isFinal(): bool;
/**
* Is the payload masked?
* @return bool
*/
public function isMasked(): bool;
/**
* @return int
*/
public function getOpcode(): int;
/**
* @return int
*/
//public function getReceivedPayloadLength(): int;
/**
* 32-big string
* @return string
*/
public function getMaskingKey(): string;
}

126
vendor/ratchet/rfc6455/src/Messaging/Message.php vendored Executable file
View File

@@ -0,0 +1,126 @@
<?php
namespace Ratchet\RFC6455\Messaging;
class Message implements \IteratorAggregate, MessageInterface {
private \SplDoublyLinkedList $_frames;
private int $len;
public function __construct() {
$this->_frames = new \SplDoublyLinkedList;
$this->len = 0;
}
public function getIterator(): \Traversable {
return $this->_frames;
}
/**
* {@inheritdoc}
*/
public function count(): int {
return count($this->_frames);
}
/**
* {@inheritdoc}
*/
public function isCoalesced(): bool {
if (count($this->_frames) == 0) {
return false;
}
$last = $this->_frames->top();
return $last->isCoalesced() && $last->isFinal();
}
/**
* {@inheritdoc}
*/
public function addFrame(FrameInterface $fragment): MessageInterface {
$this->len += $fragment->getPayloadLength();
$this->_frames->push($fragment);
return $this;
}
/**
* {@inheritdoc}
*/
public function getOpcode(): int {
if (count($this->_frames) == 0) {
throw new \UnderflowException('No frames have been added to this message');
}
return $this->_frames->bottom()->getOpcode();
}
/**
* {@inheritdoc}
*/
public function getPayloadLength(): int {
return $this->len;
}
/**
* {@inheritdoc}
*/
public function getPayload(): string {
if (!$this->isCoalesced()) {
throw new \UnderflowException('Message has not been put back together yet');
}
return $this->__toString();
}
/**
* {@inheritdoc}
*/
public function getContents(): string {
if (!$this->isCoalesced()) {
throw new \UnderflowException("Message has not been put back together yet");
}
$buffer = '';
foreach ($this->_frames as $frame) {
$buffer .= $frame->getContents();
}
return $buffer;
}
public function __toString(): string {
$buffer = '';
foreach ($this->_frames as $frame) {
$buffer .= $frame->getPayload();
}
return $buffer;
}
/**
* @return boolean
*/
public function isBinary(): bool {
if ($this->_frames->isEmpty()) {
throw new \UnderflowException('Not enough data has been received to determine if message is binary');
}
return Frame::OP_BINARY === $this->_frames->bottom()->getOpcode();
}
/**
* @return boolean
*/
public function getRsv1(): bool {
if ($this->_frames->isEmpty()) {
return false;
//throw new \UnderflowException('Not enough data has been received to determine if message is binary');
}
return $this->_frames->bottom()->getRsv1();
}
}

529
vendor/ratchet/rfc6455/src/Messaging/MessageBuffer.php vendored Executable file
View File

@@ -0,0 +1,529 @@
<?php
namespace Ratchet\RFC6455\Messaging;
use Ratchet\RFC6455\Handshake\PermessageDeflateOptions;
class MessageBuffer {
private CloseFrameChecker $closeFrameChecker;
/**
* @var callable
*/
private $exceptionFactory;
private ?MessageInterface $messageBuffer = null;
private ?FrameInterface $frameBuffer = null;
/**
* @var callable
*/
private $onMessage;
/**
* @var callable
*/
private $onControl;
private bool $checkForMask;
/**
* @var callable
*/
private $sender;
private string $leftovers = '';
private int $streamingMessageOpCode = -1;
private PermessageDeflateOptions $permessageDeflateOptions;
private bool $deflateEnabled;
private int $maxMessagePayloadSize;
private int $maxFramePayloadSize;
private bool $compressedMessage = false;
/**
* @var resource|bool|null
*/
private $inflator = null;
/**
* @var resource|bool|null
*/
private $deflator = null;
public function __construct(
CloseFrameChecker $frameChecker,
callable $onMessage,
?callable $onControl = null,
bool $expectMask = true,
?callable $exceptionFactory = null,
?int $maxMessagePayloadSize = null, // null for default - zero for no limit
?int $maxFramePayloadSize = null, // null for default - zero for no limit
?callable $sender = null,
?PermessageDeflateOptions $permessageDeflateOptions = null
) {
$this->closeFrameChecker = $frameChecker;
$this->checkForMask = $expectMask;
$this->exceptionFactory = $exceptionFactory ?: static fn (string $msg) => new \UnderflowException($msg);
$this->onMessage = $onMessage;
$this->onControl = $onControl ?: static function (): void {};
$this->sender = $sender;
$this->permessageDeflateOptions = $permessageDeflateOptions ?: PermessageDeflateOptions::createDisabled();
$this->deflateEnabled = $this->permessageDeflateOptions->isEnabled();
if ($this->deflateEnabled && !is_callable($this->sender)) {
throw new \InvalidArgumentException('sender must be set when deflate is enabled');
}
$memory_limit_bytes = static::getMemoryLimit();
if ($maxMessagePayloadSize === null) {
$maxMessagePayloadSize = (int)($memory_limit_bytes / 4);
}
if ($maxFramePayloadSize === null) {
$maxFramePayloadSize = (int)($memory_limit_bytes / 4);
}
if ($maxFramePayloadSize > 0x7FFFFFFFFFFFFFFF || $maxFramePayloadSize < 0) { // this should be interesting on non-64 bit systems
throw new \InvalidArgumentException($maxFramePayloadSize . ' is not a valid maxFramePayloadSize');
}
$this->maxFramePayloadSize = $maxFramePayloadSize;
if ($maxMessagePayloadSize > 0x7FFFFFFFFFFFFFFF || $maxMessagePayloadSize < 0) {
throw new \InvalidArgumentException($maxMessagePayloadSize . 'is not a valid maxMessagePayloadSize');
}
$this->maxMessagePayloadSize = $maxMessagePayloadSize;
}
public function onData(string $data): void {
$data = $this->leftovers . $data;
$dataLen = strlen($data);
if ($dataLen < 2) {
$this->leftovers = $data;
return;
}
$frameStart = 0;
while ($frameStart + 2 <= $dataLen) {
$headerSize = 2;
$payload_length = unpack('C', $data[$frameStart + 1] & "\x7f")[1];
$isMasked = ($data[$frameStart + 1] & "\x80") === "\x80";
$headerSize += $isMasked ? 4 : 0;
$payloadLenOver2GB = false;
if ($payload_length > 125 && ($dataLen - $frameStart < $headerSize + 125)) {
// no point of checking - this frame is going to be bigger than the buffer is right now
break;
}
if ($payload_length > 125) {
$payloadLenBytes = $payload_length === 126 ? 2 : 8;
$headerSize += $payloadLenBytes;
$bytesToUpack = substr($data, $frameStart + 2, $payloadLenBytes);
if ($payload_length === 126){
$payload_length = unpack('n', $bytesToUpack)[1];
} else {
$payloadLenOver2GB = unpack('N', $bytesToUpack)[1] > 0; //Decode only the 4 first bytes
if (PHP_INT_SIZE == 4) { // if 32bits PHP
$bytesToUpack = substr($bytesToUpack, 4); //Keep only 4 last bytes
$payload_length = unpack('N', $bytesToUpack)[1];
} else {
$payload_length = unpack('J', $bytesToUpack)[1];
}
}
}
$closeFrame = null;
if ($payload_length < 0) {
// this can happen when unpacking in php
$closeFrame = $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Invalid frame length');
}
if (!$closeFrame && PHP_INT_SIZE == 4 && $payloadLenOver2GB) {
$closeFrame = $this->newCloseFrame(Frame::CLOSE_TOO_BIG, 'Frame over 2GB can\'t be handled on 32bits PHP');
}
if (!$closeFrame && $this->maxFramePayloadSize > 1 && $payload_length > $this->maxFramePayloadSize) {
$closeFrame = $this->newCloseFrame(Frame::CLOSE_TOO_BIG, 'Maximum frame size exceeded');
}
if (!$closeFrame && $this->maxMessagePayloadSize > 0
&& $payload_length + ($this->messageBuffer ? $this->messageBuffer->getPayloadLength() : 0) > $this->maxMessagePayloadSize) {
$closeFrame = $this->newCloseFrame(Frame::CLOSE_TOO_BIG, 'Maximum message size exceeded');
}
if ($closeFrame !== null) {
$onControl = $this->onControl;
$onControl($closeFrame);
$this->leftovers = '';
return;
}
$isCoalesced = $dataLen - $frameStart >= $payload_length + $headerSize;
if (!$isCoalesced) {
break;
}
$this->processData(substr($data, $frameStart, $payload_length + $headerSize));
$frameStart = $frameStart + $payload_length + $headerSize;
}
$this->leftovers = substr($data, $frameStart);
}
/**
* @param string $data
* @return void
*/
private function processData(string $data): void {
$this->messageBuffer ?: $this->messageBuffer = $this->newMessage();
$this->frameBuffer ?: $this->frameBuffer = $this->newFrame();
$this->frameBuffer->addBuffer($data);
$onMessage = $this->onMessage;
$onControl = $this->onControl;
$this->frameBuffer = $this->frameCheck($this->frameBuffer);
$this->frameBuffer->unMaskPayload();
$opcode = $this->frameBuffer->getOpcode();
if ($opcode > 2) {
$onControl($this->frameBuffer, $this);
if (Frame::OP_CLOSE === $opcode) {
return;
}
} else {
if ($this->messageBuffer->count() === 0 && $this->frameBuffer->getRsv1()) {
$this->compressedMessage = true;
}
if ($this->compressedMessage) {
$this->frameBuffer = $this->inflateFrame($this->frameBuffer);
}
$this->messageBuffer->addFrame($this->frameBuffer);
}
$this->frameBuffer = null;
if ($this->messageBuffer->isCoalesced()) {
$msgCheck = $this->checkMessage($this->messageBuffer);
$msgBuffer = $this->messageBuffer;
$this->messageBuffer = null;
if (true !== $msgCheck) {
$onControl($this->newCloseFrame($msgCheck, 'Ratchet detected an invalid UTF-8 payload'), $this);
} else {
$onMessage($msgBuffer, $this);
}
$this->messageBuffer = null;
$this->compressedMessage = false;
if ($this->permessageDeflateOptions->getServerNoContextTakeover()) {
$this->inflator = null;
}
}
}
/**
* Check a frame to be added to the current message buffer
* @param FrameInterface $frame
* @return FrameInterface
*/
public function frameCheck(FrameInterface $frame): FrameInterface {
if ((false !== $frame->getRsv1() && !$this->deflateEnabled) ||
false !== $frame->getRsv2() ||
false !== $frame->getRsv3()
) {
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected an invalid reserve code');
}
if ($this->checkForMask && !$frame->isMasked()) {
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected an incorrect frame mask');
}
$opcode = $frame->getOpcode();
if ($opcode > 2) {
if ($frame->getPayloadLength() > 125 || !$frame->isFinal()) {
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected a mismatch between final bit and indicated payload length');
}
switch ($opcode) {
case Frame::OP_CLOSE:
$closeCode = 0;
$bin = $frame->getPayload();
if (empty($bin)) {
return $this->newCloseFrame(Frame::CLOSE_NORMAL);
}
if (strlen($bin) === 1) {
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected an invalid close code');
}
if (strlen($bin) >= 2) {
list($closeCode) = array_merge(unpack('n*', substr($bin, 0, 2)));
}
$checker = $this->closeFrameChecker;
if (!$checker($closeCode)) {
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected an invalid close code');
}
if (!$this->checkUtf8(substr($bin, 2))) {
return $this->newCloseFrame(Frame::CLOSE_BAD_PAYLOAD, 'Ratchet detected an invalid UTF-8 payload in the close reason');
}
return $frame;
case Frame::OP_PING:
case Frame::OP_PONG:
break;
default:
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected an invalid OP code');
}
return $frame;
}
if (Frame::OP_CONTINUE === $frame->getOpcode() && 0 === count($this->messageBuffer)) {
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected the first frame of a message was a continue');
}
if (count($this->messageBuffer) > 0 && Frame::OP_CONTINUE !== $frame->getOpcode()) {
return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected invalid OP code when expecting continue frame');
}
return $frame;
}
/**
* Determine if a message is valid
* @param MessageInterface
* @return bool|int true if valid - false if incomplete - int of recommended close code
*/
public function checkMessage(MessageInterface $message) {
if (!$message->isBinary()) {
if (!$this->checkUtf8($message->getPayload())) {
return Frame::CLOSE_BAD_PAYLOAD;
}
}
return true;
}
private function checkUtf8(string $string): bool {
if (extension_loaded('mbstring')) {
return mb_check_encoding($string, 'UTF-8');
}
return preg_match('//u', $string);
}
/**
* @return MessageInterface
*/
public function newMessage(): MessageInterface {
return new Message;
}
/**
* @param string|null $payload
* @param bool $final
* @param int $opcode
* @return FrameInterface
*/
public function newFrame(?string $payload = null, bool $final = true, int $opcode = Frame::OP_TEXT): FrameInterface {
return new Frame($payload, $final, $opcode, $this->exceptionFactory);
}
public function newCloseFrame(int $code, string $reason = ''): FrameInterface {
return $this->newFrame(pack('n', $code) . $reason, true, Frame::OP_CLOSE);
}
public function sendFrame(FrameInterface $frame): void {
if ($this->sender === null) {
throw new \Exception('To send frames using the MessageBuffer, sender must be set.');
}
if ($this->deflateEnabled &&
($frame->getOpcode() === Frame::OP_TEXT || $frame->getOpcode() === Frame::OP_BINARY)) {
$frame = $this->deflateFrame($frame);
}
if (!$this->checkForMask) {
$frame->maskPayload();
}
$sender = $this->sender;
$sender($frame->getContents());
}
public function sendMessage(string $messagePayload, bool $final = true, bool $isBinary = false): void {
$opCode = $isBinary ? Frame::OP_BINARY : Frame::OP_TEXT;
if ($this->streamingMessageOpCode === -1) {
$this->streamingMessageOpCode = $opCode;
}
if ($this->streamingMessageOpCode !== $opCode) {
throw new \Exception('Binary and text message parts cannot be streamed together.');
}
$frame = $this->newFrame($messagePayload, $final, $opCode);
$this->sendFrame($frame);
if ($final) {
// reset deflator if client doesn't remember contexts
if ($this->getDeflateNoContextTakeover()) {
$this->deflator = null;
}
$this->streamingMessageOpCode = -1;
}
}
private function getDeflateNoContextTakeover(): ?bool {
return $this->checkForMask ?
$this->permessageDeflateOptions->getServerNoContextTakeover() :
$this->permessageDeflateOptions->getClientNoContextTakeover();
}
private function getDeflateWindowBits(): int {
return $this->checkForMask ? $this->permessageDeflateOptions->getServerMaxWindowBits() : $this->permessageDeflateOptions->getClientMaxWindowBits();
}
private function getInflateNoContextTakeover(): ?bool {
return $this->checkForMask ?
$this->permessageDeflateOptions->getClientNoContextTakeover() :
$this->permessageDeflateOptions->getServerNoContextTakeover();
}
private function getInflateWindowBits(): int {
return $this->checkForMask ? $this->permessageDeflateOptions->getClientMaxWindowBits() : $this->permessageDeflateOptions->getServerMaxWindowBits();
}
private function inflateFrame(FrameInterface $frame): Frame {
if ($this->inflator === null) {
$this->inflator = inflate_init(
ZLIB_ENCODING_RAW,
[
'level' => -1,
'memory' => 8,
'window' => $this->getInflateWindowBits(),
'strategy' => ZLIB_DEFAULT_STRATEGY
]
);
}
$terminator = '';
if ($frame->isFinal()) {
$terminator = "\x00\x00\xff\xff";
}
gc_collect_cycles(); // memory runs away if we don't collect ??
return new Frame(
inflate_add($this->inflator, $frame->getPayload() . $terminator),
$frame->isFinal(),
$frame->getOpcode()
);
}
private function deflateFrame(FrameInterface $frame): FrameInterface
{
if ($frame->getRsv1()) {
return $frame; // frame is already deflated
}
if ($this->deflator === null) {
$bits = $this->getDeflateWindowBits();
if ($bits === 8) {
$bits = 9;
}
$this->deflator = deflate_init(
ZLIB_ENCODING_RAW,
[
'level' => -1,
'memory' => 8,
'window' => $bits,
'strategy' => ZLIB_DEFAULT_STRATEGY
]
);
}
// there is an issue in the zlib extension for php where
// deflate_add does not check avail_out to see if the buffer filled
// this only seems to be an issue for payloads between 16 and 64 bytes
// This if statement is a hack fix to break the output up allowing us
// to call deflate_add twice which should clear the buffer issue
// if ($frame->getPayloadLength() >= 16 && $frame->getPayloadLength() <= 64) {
// // try processing in 8 byte chunks
// // https://bugs.php.net/bug.php?id=73373
// $payload = "";
// $orig = $frame->getPayload();
// $partSize = 8;
// while (strlen($orig) > 0) {
// $part = substr($orig, 0, $partSize);
// $orig = substr($orig, strlen($part));
// $flags = strlen($orig) > 0 ? ZLIB_PARTIAL_FLUSH : ZLIB_SYNC_FLUSH;
// $payload .= deflate_add($this->deflator, $part, $flags);
// }
// } else {
$payload = deflate_add(
$this->deflator,
$frame->getPayload(),
ZLIB_SYNC_FLUSH
);
// }
$deflatedFrame = new Frame(
substr($payload, 0, $frame->isFinal() ? -4 : strlen($payload)),
$frame->isFinal(),
$frame->getOpcode()
);
if ($frame->isFinal()) {
$deflatedFrame->setRsv1();
}
return $deflatedFrame;
}
/**
* This is a separate function for testing purposes
* $memory_limit is only used for testing
*
* @param null|string $memory_limit
* @return int
*/
private static function getMemoryLimit(?string $memory_limit = null): int {
$memory_limit = $memory_limit === null ? \trim(\ini_get('memory_limit')) : $memory_limit;
$memory_limit_bytes = 0;
if ($memory_limit !== '') {
$shifty = ['k' => 0, 'm' => 10, 'g' => 20];
$multiplier = strlen($memory_limit) > 1 ? substr(strtolower($memory_limit), -1) : '';
$memory_limit = (int)$memory_limit;
$memory_limit_bytes = in_array($multiplier, array_keys($shifty), true) ? $memory_limit * 1024 << $shifty[$multiplier] : $memory_limit;
}
return $memory_limit_bytes < 0 ? 0 : $memory_limit_bytes;
}
}

20
vendor/ratchet/rfc6455/src/Messaging/MessageInterface.php vendored Executable file
View File

@@ -0,0 +1,20 @@
<?php
namespace Ratchet\RFC6455\Messaging;
interface MessageInterface extends DataInterface, \Traversable, \Countable {
/**
* @param FrameInterface $fragment
* @return MessageInterface
*/
public function addFrame(FrameInterface $fragment): self;
/**
* @return int
*/
public function getOpcode(): int;
/**
* @return bool
*/
public function isBinary(): bool;
}