Helix\Socket\WebSocket\Handshake

Complexity

Total Complexity

24

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	getHeaders()	0	3	1
A	getMethod()	0	3	1
B	onReadable()	0	54	9
A	upgrade()	0	9	1
B	validate()	0	16	11

<?php

namespace Helix\Socket\WebSocket;

use Throwable;

/**
 * Initial WebSocket connection handshake.
 *
 * https://tools.ietf.org/html/rfc6455#section-1.3
 */
class Handshake {

    const RFC_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';

    /**
     * @var string
     */
    protected $buffer = '';

    /**
     * @var WebSocketClient
     */
    protected $client;

    /**
     * [ header name => lowercase value  => actual value ]
     *
     * @var string[][]
     */
    protected $headers = [];

    /**
     * The connection is closed (HTTP 413) if the received headers exceed this many bytes.
     *
     * @var int
     */
    protected $maxLength = 4096;

    /**
     * @var string
     */
    protected $method;

    /**
     * @param WebSocketClient $client
     */
    public function __construct (WebSocketClient $client) {
        $this->client = $client;
    }

    /**
     * @return string[][]
     */
    public function getHeaders () {
        return $this->headers;
    }

    /**
     * @return string
     */
    public function getMethod (): string {
        return $this->method;
    }

    /**
     * Negotiates the initial connection.
     *
     * @return bool
     * @throws WebSocketError
     * @throws Throwable
     */
    public function onReadable (): bool {
        // read into the buffer
        $this->buffer .= $bytes = $this->client->recvAll();

        // check for peer disconnection
        if (!strlen($bytes)) {
            $this->client->close();
            return false;
        }

        // read frames from the buffer and yield
        try {
            // length check
            if (strlen($this->buffer) > $this->maxLength) {
                throw new WebSocketError(413, "{$this->client} exceeded the maximum handshake size.");
            }
            // still reading?
            if (false === $end = strpos($this->buffer, "\r\n\r\n")) {
                return false;
            }
            // parse the headers
            $head = explode("\r\n", substr($this->buffer, 0, $end));
            $this->method = array_shift($head);
            foreach ($head as $header) {
                $header = explode(':', $header, 2);
                if (count($header) !== 2) {
                    throw new WebSocketError(400, "{$this->client} sent a malformed header.");
                }
                [$key, $value] = $header;

The variable $key does not seem to be defined for all execution paths leading up to this point.

The variable $value does not seem to be defined for all execution paths leading up to this point.

                $key = strtolower(trim($key));
                foreach (explode(', ', $value) as $value) {
                    $value = trim($value);
                    $this->headers[$key][strtolower($value)] = $value;
                }
            }
            $this->buffer = ''; // wipe the buffer
            $this->validate();
        }
        catch (WebSocketError $e) { // catch and respond with HTTP error and rethrow
            $this->client->write("HTTP/1.1 {$e->getCode()} WebSocket Handshake Failure\r\n\r\n");
            throw $e;
        }
        catch (Throwable $e) { // catch everything else and respond with HTTP 500 and rethrow
            $this->client->write("HTTP/1.1 500 WebSocket Internal Error\r\n\r\n");
            throw $e;
        }

        // send upgrade headers
        $this->upgrade();
        $this->client->write("\r\n\r\n");

        // success
        return true;
    }

    /**
     * Sends the connection upgrade headers.
     */
    protected function upgrade (): void {
        $key = base64_encode(sha1(current($this->headers['sec-websocket-key']) . self::RFC_GUID, true));
        $this->client->write(implode("\r\n", [
            "HTTP/1.1 101 Switching Protocols",
            "Connection: Upgrade",
            "Upgrade: websocket",
            "Sec-WebSocket-Accept: {$key}"
        ]));
    }

    /**
     * Validates the received HTTP handshake headers, or throws.
     *
     * @throws WebSocketError
     */
    protected function validate (): void {
        if (!(
            $check = 'method = http 1.1'
            and preg_match('/HTTP\/1\.1$/i', $this->method)
            and $check = 'connection = upgrade'
            and isset($this->headers['connection']['upgrade'])
            and $check = 'upgrade = websocket'
            and isset($this->headers['upgrade']['websocket'])
            and $check = 'version = 13'
            and isset($this->headers['sec-websocket-version']['13'])
            and $check = 'key length = 16'
            and strlen(base64_decode(current($this->headers['sec-websocket-key'] ?? []))) === 16
        )) {
            throw new WebSocketError(400, "Handshake with {$this->client} failed on validation: {$check}");
        }
    }
}