WebSocketServer::acceptHandshakeVersion() - Code Metrics - Inspection of "refactored some things, init websockets" - hfw/socket - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( b4e552...a91d54 )

by y
created 2020-03-02 13:52 UTC
WebSocketServer::acceptHandshakeVersion() A

↳ Parent: WebSocketServer
Complexity

Conditions	2
Paths	2
Size

Total Lines	3
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	2
c	1
b	0
f	0
nc	2
nop	2
dl	0
loc	3
rs	10
<?php

namespace Helix\Socket;

use RuntimeException;

/**
 * https://tools.ietf.org/html/rfc6455
 */
class WebSocketServer extends StreamServer implements ReactiveInterface {

    /**
     * @var WebSocketClient[]
     */
    protected $clients = [];

    /**
     * @var Reactor
     */
    protected $reactor;

    /**
     * @param $resource
     * @param Reactor $reactor
     */
    public function __construct ($resource, Reactor $reactor) {
        parent::__construct($resource);
        $reactor->add($this);
        $this->reactor = $reactor;
    }

    /**
     * Verifies and accepts a websocket connection.
     *
     * https://tools.ietf.org/html/rfc6455#section-4.2
     * @return WebSocketClient
     */
    public function accept () {
        if (!$resource = @socket_accept($this->resource)) {
            throw new Error($this->resource); // reliable errno
        }
        $client = $this->newClient($resource);
        $this->acceptHandshake($client);
        $this->clients[$client->getId()] = $client;
        $this->reactor->add($client);
        $this->onAccept($client);
        return $client;
    }

    /**
     * @param WebSocketClient $client
     */
    protected function acceptHandshake (WebSocketClient $client) {
        $head = $client->await(self::CH_READ)->recv(4096); // todo client->readUntil(string,maxlength)
        $head = explode("\r\n", $head);
        $method = array_shift($head);
        $this->acceptHandshakeMethod($client, $method);

        $headers = [];
        foreach ($head as $header) {
            if (strlen($header)) {
                [$key, $value] = explode(':', $header, 2);
                $key = strtolower(trim($key));
                $value = trim($value);
                $headers[$key] = $value;
            }
        }

        $this->acceptHandshakeHost($client, $headers['host'] ?? '');
        $this->acceptHandshakeOrigin($client, $headers['origin'] ?? '');
        $this->acceptHandshakeConnection($client, $headers['connection'] ?? '');
        $this->acceptHandshakeUpgrade($client, $headers['upgrade'] ?? '');
        $this->acceptHandshakeVersion($client, $headers['sec-websocket-version'] ?? '');
        $base64Key = $headers['sec-websocket-key'] ?? '';
        $this->acceptHandshakeKey($client, $base64Key);

        $response = [
            "HTTP/1.1 101 Switching Protocols",
            "Upgrade: websocket",
            "Connection: Upgrade",
            "Sec-WebSocket-Accept: " . base64_encode(sha1($base64Key . '258EAFA5-E914-47DA-95CA-C5AB0DC85B11', true)),
        ];

        $client->write(implode("\r\n", $response) . "\r\n\r\n");
    }

    /**
     * @param WebSocketClient $client
     * @param string $connection
     */
    protected function acceptHandshakeConnection (WebSocketClient $client, string $connection) {
        if (!preg_match('/^upgrade$/i', $connection)) {
            $this->reject($client, "Expected: Connection: Upgrade");
        }
    }

    /**
     * Stub.
     *
     * @param WebSocketClient $client
     * @param string $host
     */
    protected function acceptHandshakeHost (WebSocketClient $client, string $host) {
    protected function acceptHandshakeHost (WebSocketClient $client, /** @scrutinizer ignore-unused */ string $host) {

    }

    /**
     * @param WebSocketClient $client
     * @param string $base64Key
     */
    protected function acceptHandshakeKey (WebSocketClient $client, string $base64Key) {
        $key = base64_decode($base64Key);
        if ($key === false or strlen($key) !== 16) {
            $this->reject($client, "Expected Sec-WebSocket-Key");
        }
    }

    /**
     * @param WebSocketClient $client
     * @param string $method
     */
    protected function acceptHandshakeMethod (WebSocketClient $client, string $method) {
        if (!preg_match('/HTTP\/1\.1$/i', $method)) {
            $this->reject($client, "Expected: HTTP/1.1");
        }
    }

    /**
     * Stub.
     *
     * @param WebSocketClient $client
     * @param string $origin
     */
    protected function acceptHandshakeOrigin (WebSocketClient $client, string $origin) {
    protected function acceptHandshakeOrigin (/** @scrutinizer ignore-unused */ WebSocketClient $client, string $origin) {

    }

    /**
     * @param WebSocketClient $client
     * @param string $upgrade
     */
    protected function acceptHandshakeUpgrade (WebSocketClient $client, string $upgrade) {
        if (!preg_match('/^websocket$/i', $upgrade)) {
            $this->reject($client, "Expected Upgrade: websocket");
        }
    }

    /**
     * @param WebSocketClient $client
     * @param string $version
     */
    protected function acceptHandshakeVersion (WebSocketClient $client, string $version) {
        if ($version !== '13') {
            $this->reject($client, "Expected Sec-WebSocket-Version: 13");
        }
    }

    /**
     * @return WebSocketClient[]
     */
    public function getClients () {
        return $this->clients;
    }

    /**
     * @param resource $resource
     * @return WebSocketClient
     */
    protected function newClient ($resource) {
        return new WebSocketClient($resource, $this);
    }

    /**
     * WebSockets do not use the out-of-band channel.
     *
     * @inheritDoc
     */
    final public function onOutOfBand () {
        // do nothing
    }

    /**
     * @inheritDoc
     */
    public function onReadable () {
        $this->accept();
    }

    /**
     * Stub.
     *
     * @param WebSocketClient $client
     * @param string $reason
     * @throws RuntimeException
     */
    protected function reject (WebSocketClient $client, string $reason) {
        throw new RuntimeException("Rejected {$client}: {$reason}");
    }

    /**
     * Removes the client from the server and reactor.
     *
     * @param WebSocketClient $client
     * @return $this
     */
    public function remove (WebSocketClient $client) {
        unset($this->clients[$client->getId()]);
        $this->reactor->remove($client->getId());
        return $this;
    }
}
hfw / socket

Push — master ( b4e552...a91d54 )

WebSocketServer::acceptHandshakeVersion() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
