Helix\Socket\WebSocket\FrameHandler

Complexity

Total Complexity

35

Size/Duplication

Total Lines	247
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	2	1
A	onFrame()	0	11	3
A	writePing()	0	2	1
A	writeText()	0	2	1
A	onBinary()	0	14	4
A	onClose()	0	2	1
A	onContinue()	0	13	3
A	onData()	0	6	3
A	write()	0	15	4
A	onText()	0	14	4
A	onControl()	0	9	4
A	onFrame_CheckRsv()	0	4	2
A	onPong()	0	1	1
A	writeBinary()	0	2	1
A	onPing()	0	2	1
A	writePong()	0	2	1

<?php

namespace Helix\Socket\WebSocket;

/**
 * Handles received frames from the peer, and packs and sends frames.
 */
class FrameHandler {

    /**
     * The binary message buffer when streaming is disabled.
     *
     * @var string
     */
    protected $binary = '';

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

    /**
     * Opcode for the `CONTINUE` handler.
     *
     * @var int|null
     */
    protected $continue;

    /**
     * The text message buffer when streaming is disabled.
     *
     * @var string
     */
    protected $text = '';

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

    /**
     * When a `BINARY` frame is received.
     *
     * Throws by default.
     *
     * @param Frame $binary
     */
    protected function onBinary (Frame $binary): void {
        $handler = $this->client->getMessageHandler();
        if ($handler->isBinaryStream()) {
            $handler->onBinary($binary->getPayload());
        }
        else {
            if (strlen($this->binary) + $binary->getLength() > $handler->getMaxLength()) {
                throw new WebSocketError(Frame::CLOSE_TOO_LARGE, $handler->getMaxLength(), $binary);
            }
            $this->binary .= $binary->getPayload();
            if ($binary->isFinal()) {
                $message = $this->binary;
                $this->binary = '';
                $handler->onBinary($message);
            }
        }
    }

    /**
     * When a `CLOSE` frame is received.
     *
     * https://tools.ietf.org/html/rfc6455#section-5.5.1
     * > If an endpoint receives a Close frame and did not previously send a
     * > Close frame, the endpoint MUST send a Close frame in response.  (When
     * > sending a Close frame in response, the endpoint typically echos the
     * > status code it received.)
     *
     * @param Frame $close
     */
    protected function onClose (Frame $close): void {
        $this->client->close($close->getCloseCode());
    }

    /**
     * When a `CONTINUE` data fragment is received.
     *
     * @param Frame $frame
     */
    protected function onContinue (Frame $frame): void {
        switch ($this->continue) {
            case Frame::OP_TEXT:
                $this->onText($frame);
                break;
            case Frame::OP_BINARY:
                $this->onBinary($frame);
                break;
            default:
                throw new WebSocketError(
                    Frame::CLOSE_PROTOCOL_ERROR,
                    "Received CONTINUE without a prior fragment.",
                    $frame
                );
        }
    }

    /**
     * When a control frame is received.
     *
     * https://tools.ietf.org/html/rfc6455#section-5.4
     * > Control frames (see Section 5.5) MAY be injected in the middle of
     * > a fragmented message.
     *
     * @param Frame $control
     */
    protected function onControl (Frame $control): void {
        if ($control->isClose()) {
            $this->onClose($control);
        }
        elseif ($control->isPing()) {
            $this->onPing($control);
        }
        elseif ($control->isPong()) {
            $this->onPong($control);
        }
    }

    /**
     * When an initial data frame (not `CONTINUE`) is received.
     *
     * @param Frame $data
     */
    protected function onData (Frame $data): void {
        if ($data->isText()) {
            $this->onText($data);
        }
        elseif ($data->isBinary()) {
            $this->onBinary($data);
        }
    }

    /**
     * Invoked by the client when a complete frame has been received.
     *
     * Delegates to the other handler methods using the control flow outlined in the RFC.
     *
     * @param Frame $frame
     */
    public function onFrame (Frame $frame): void {
        $this->onFrame_CheckRsv($frame);
        $frame->validate();
        if ($frame->isControl()) {
            $this->onControl($frame);
        }
        elseif ($frame->isContinue()) {
            $this->onContinue($frame);
        }
        else {
            $this->onData($frame);
        }
    }

    /**
     * Throws if unknown RSV bits are received.
     *
     * @param Frame $frame
     */
    protected function onFrame_CheckRsv (Frame $frame): void {
        if ($badRsv = $frame->getRsv() & ~$this->client->getHandshake()->getRsv()) {
            $badRsv = str_pad(base_convert($badRsv, 10, 2), 3, 0, STR_PAD_LEFT);
            throw new WebSocketError(Frame::CLOSE_PROTOCOL_ERROR, "Received unknown RSV: 0b{$badRsv}");
        }
    }

    /**
     * When a `PING` frame is received.
     *
     * Automatically pongs the payload back by default.
     *
     * @param Frame $ping
     */
    protected function onPing (Frame $ping): void {
        $this->writePong($ping->getPayload());
    }

    /**
     * When a `PONG` frame is received.
     *
     * Does nothing by default.
     *
     * @param Frame $pong
     */
    protected function onPong (Frame $pong): void {

The parameter $pong is not used and could be removed.

        // stub
    }

    /**
     * When a `BINARY` frame is received.
     *
     * Throws by default.
     *
     * @param Frame $text
     */
    protected function onText (Frame $text): void {
        $handler = $this->client->getMessageHandler();
        if ($handler->isTextStream()) {
            $handler->onText($text->getPayload());
        }
        else {
            if (strlen($this->text) + $text->getLength() > $handler->getMaxLength()) {
                throw new WebSocketError(Frame::CLOSE_TOO_LARGE, $handler->getMaxLength(), $text);
            }
            $this->text .= $text->getPayload();
            if ($text->isFinal()) {
                $message = $this->text;
                $this->text = '';
                $handler->onText($message);
            }
        }
    }

    /**
     * Writes a frame to the peer.
     *
     * @param string $payload
     * @param int $opCode
     * @param bool $final
     */
    public function write (string $payload, int $opCode = Frame::OP_TEXT, bool $final = true): void {
        $head = chr(($final ? 0x80 : 0) | $opCode);
        $length = strlen($payload);
        if ($length > 65535) {
            $head .= chr(127);
            $head .= pack('J', $length);
        }
        elseif ($length >= 126) {
            $head .= chr(126);
            $head .= pack('n', $length);
        }
        else {
            $head .= chr($length);
        }
        $this->client->write($head . $payload);
    }

    public function writeBinary (string $payload, bool $final = true): void {
        $this->write($payload, Frame::OP_BINARY, $final);
    }

    public function writePing (string $payload = ''): void {
        $this->write($payload, Frame::OP_PING);
    }

    public function writePong (string $payload = ''): void {
        $this->write($payload, Frame::OP_PONG);
    }

    public function writeText (string $payload, bool $final = true): void {
        $this->write($payload, Frame::OP_TEXT, $final);
    }
}