FrameReader::recvAll() - Code Metrics - Inspection of "more overhauling" - hfw/socket - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( a91d54...875978 )

by y
created 2020-03-09 13:11 UTC
FrameReader::recvAll() A

↳ Parent: FrameReader
Complexity

Conditions	2
Paths	2
Size

Total Lines	4
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

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

namespace Helix\Socket\WebSocket;

use Generator;

/**
 * Reads frames from the peer.
 */
class FrameReader {

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

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

    /**
     * @var array
     */
    protected $current = [];

    /**
     * Payload size limit imposed on large frames.
     *
     * @var int
     */
    protected $sizeLimit = 10 * 1024 * 1024; // 10 MiB

    public function __construct (WebSocketClient $client) {
        $this->client = $client;
    }

    /**
     * @return int
     */
    public function getSizeLimit (): int {
        return $this->sizeLimit;
    }

    /**
     * @return Frame|null
     */
    protected function parse () {
        if (
            $this->parse_1_opCode()
            and $this->parse_2_length()
            and $this->parse_3_mask()
            and $this->parse_4_payload()
        ) {
            $frame = new Frame(
                $this->current['final'],
                $this->current['rsv'],
                $this->current['opCode'],
                $this->current['payload']
            );
            $this->current = [];
            $frame->validate();
            return $frame;
        }
        return null;
    }

    /**
     * @return bool
     */
    protected function parse_1_opCode (): bool {
        if (!isset($this->current['opCode'])) {
            if (null === $char = $this->shift(1)) {
                return false;
            }
            $char = ord($char);
            $final = (bool)($char & 0x80);
            $opCode = $char & 0x0f;
            $this->current = [
                'final' => $final,
                'rsv' => ($char & 0x70) >> 4,
                'opCode' => $opCode
            ];
        }
        return true;
    }

    /**
     * The protocol unfortunately uses different field sizes to specify the payload length.
     *
     * The high bit of the initial length specifier is also used for something completely unrelated (masking).
     *
     * On top of the added complexity, because the dynamic field is for the payload length,
     * this requires a variable named something akin to "lengthLength".
     *
     * Was a constant unpolluted 32-bit field too much to ask?
     *
     * Who is sending 2^63 bytes in a single frame?
     *
     * @return bool
     */
    protected function parse_2_length (): bool {
        // first pass
        if (!isset($this->current['lengthSize'])) {
            if (null === $byte = $this->shift(1)) {
                return false;
            }
            $byte = ord($byte);
            if (!$this->current['masked'] = (bool)($byte & 0x80)) {
                $this->current['mask'] = [0, 0, 0, 0]; // xor identity
            }
            $sizeIndicator = $byte & 0x7f;
            if (1 === $this->current['lengthSize'] = [126 => 2, 127 => 8][$sizeIndicator] ?? 1) {
                $this->current['length'] = $sizeIndicator;
            }
        }
        // second pass
        if (!isset($this->current['length'])) {
            $lengthSize = $this->current['lengthSize'];
            if (null === $length = $this->shift($lengthSize)) {
                return false;
            }
            $length = unpack([2 => 'n', 8 => 'J'][$lengthSize], $length)[1];
            if ($length > $this->sizeLimit) {
                throw new WebSocketError(Frame::CLOSE_TOO_LARGE, "Payload size limit is {$this->sizeLimit} bytes.");
            }
            $this->current['length'] = $length;
        }
        return true;
    }

    /**
     * The protocol requires clients to XOR flip the payload with a high-entropy mask,
     * which adds lots of arbitrary complexity without gaining any bonus whatsoever.
     *
     * The mask is sent with the frame itself, so any sophisticated eavesdropper can decode the message.
     *
     * @link https://tools.ietf.org/html/rfc6455#section-5.2
     *  Page 29: "All frames sent from client to server have this bit set to 1."
     *
     * @return bool
     */
    protected function parse_3_mask (): bool {
        if (!isset($this->current['mask'])) {
            if (null === $mask = $this->shift(4)) {
                return false;
            }
            $this->current['mask'] = array_values(unpack('C*', $mask));
            $this->current['mask'] = array_values(/** @scrutinizer ignore-type */ unpack('C*', $mask));
        }
        return true;
    }

    /**
     * @return bool
     */
    protected function parse_4_payload (): bool {
        if (!isset($this->current['payload'])) {
            $length = $this->current['length'];
            if (null === $payload = $this->shift($length)) {
                return false;
            }
            if ($this->current['masked']) {
                $mask = $this->current['mask'];
                for ($i = 0; $i < $length; $i++) {
                    $payload[$i] = chr(ord($payload[$i]) ^ $mask[$i % 4]);
                }
            }
            $this->current['payload'] = $payload;
        }
        return true;
    }

    /**
     * Constructs and yields all available frames from the peer.
     *
     * @return Generator|Frame[]
     */
    public function recvAll () {
        $this->buffer .= $this->client->recvAll();
        while ($frame = $this->parse()) {
            yield $frame;
        }
    }

    /**
     * @param int $bytes
     * @return $this
     */
    public function setSizeLimit (int $bytes) {
        $this->sizeLimit = $bytes;
        return $this;
    }

    /**
     * Shifts off and returns bytes from the buffer, but only if they're all there.
     *
     * @param int $bytes
     * @return null|string
     */
    protected function shift (int $bytes): ?string {
        if (strlen($this->buffer) < $bytes) {
            return null;
        }
        $chunk = substr($this->buffer, 0, $bytes);
        $this->buffer = substr($this->buffer, $bytes);
        return $chunk;
    }
}
hfw / socket

Push — master ( a91d54...875978 )

FrameReader::recvAll() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
