Initial Commit

7 files changed, 943 insertions, 0 deletions

diff --git a/assets/php/vendor/ratchet/rfc6455/src/Messaging/CloseFrameChecker.php b/assets/php/vendor/ratchet/rfc6455/src/Messaging/CloseFrameChecker.php
new file mode 100644
index 0000000..3d800e5
--- /dev/null
+++ b/assets/php/vendor/ratchet/rfc6455/src/Messaging/CloseFrameChecker.php
@@ -0,0 +1,24 @@
+<?php
+namespace Ratchet\RFC6455\Messaging;
+
+class CloseFrameChecker {
+    private $validCloseCodes = [];
+
+    public function __construct() {
+        $this->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($val) {
+        return ($val >= 3000 && $val <= 4999) || in_array($val, $this->validCloseCodes);
+    }
+}
diff --git a/assets/php/vendor/ratchet/rfc6455/src/Messaging/DataInterface.php b/assets/php/vendor/ratchet/rfc6455/src/Messaging/DataInterface.php
new file mode 100644
index 0000000..18aa2e3
--- /dev/null
+++ b/assets/php/vendor/ratchet/rfc6455/src/Messaging/DataInterface.php
@@ -0,0 +1,34 @@
+<?php
+namespace Ratchet\RFC6455\Messaging;
+
+interface DataInterface {
+    /**
+     * Determine if the message is complete or still fragmented
+     * @return bool
+     */
+    function isCoalesced();
+
+    /**
+     * Get the number of bytes the payload is set to be
+     * @return int
+     */
+    function getPayloadLength();
+
+    /**
+     * Get the payload (message) sent from peer
+     * @return string
+     */
+    function getPayload();
+
+    /**
+     * Get raw contents of the message
+     * @return string
+     */
+    function getContents();
+
+    /**
+     * Should return the unmasked payload received from peer
+     * @return string
+     */
+    function __toString();
+}
diff --git a/assets/php/vendor/ratchet/rfc6455/src/Messaging/Frame.php b/assets/php/vendor/ratchet/rfc6455/src/Messaging/Frame.php
new file mode 100644
index 0000000..40f9eb2
--- /dev/null
+++ b/assets/php/vendor/ratchet/rfc6455/src/Messaging/Frame.php
@@ -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
+     * @var string
+     */
+    protected $data = '';
+
+    /**
+     * Number of bytes received from the frame
+     * @var int
+     */
+    public $bytesRecvd = 0;
+
+    /**
+     * Number of bytes in the payload (as per framing protocol)
+     * @var int
+     */
+    protected $defPayLen = -1;
+
+    /**
+     * If the frame is coalesced this is true
+     * This is to prevent doing math every time ::isCoalesced is called
+     * @var boolean
+     */
+    private $isCoalesced = false;
+
+    /**
+     * The unpacked first byte of the frame
+     * @var int
+     */
+    protected $firstByte = -1;
+
+    /**
+     * The unpacked second byte of the frame
+     * @var int
+     */
+    protected $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($payload = null, $final = true, $opcode = 1, callable $ufExceptionFactory = null) {
+        $this->ufeg = $ufExceptionFactory ?: function($msg = '') {
+            return 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() {
+        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($buf) {
+        $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() {
+        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);
+    }
+
+    /**
+     * @return boolean
+     * @throws \UnderflowException
+     */
+    public function getRsv1() {
+        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() {
+        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() {
+        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() {
+        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() {
+        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() {
+        $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($maskingKey = null) {
+        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() {
+        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($maskingKey, $payload = null) {
+        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);
+
+        // TODO: Remove this before publish - keeping methods here to compare performance (above is faster but need control against v0.3.3)
+
+        $applied = '';
+        for ($i = 0, $len = strlen($payload); $i < $len; $i++) {
+            $applied .= $payload[$i] ^ $maskingKey[$i % static::MASK_LENGTH];
+        }
+
+        return $applied;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOpcode() {
+        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() {
+        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() {
+        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() {
+        return (1 + $this->getNumPayloadBits()) / 8;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPayloadLength() {
+        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() {
+        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() {
+        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() {
+        return substr($this->data, 0, $this->getPayloadStartingByte() + $this->getPayloadLength());
+    }
+
+    public function __toString() {
+        $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() {
+        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 '';
+    }
+}
diff --git a/assets/php/vendor/ratchet/rfc6455/src/Messaging/FrameInterface.php b/assets/php/vendor/ratchet/rfc6455/src/Messaging/FrameInterface.php
new file mode 100644
index 0000000..dc24091
--- /dev/null
+++ b/assets/php/vendor/ratchet/rfc6455/src/Messaging/FrameInterface.php
@@ -0,0 +1,38 @@
+<?php
+namespace Ratchet\RFC6455\Messaging;
+
+interface FrameInterface extends DataInterface {
+    /**
+     * Add incoming data to the frame from peer
+     * @param string
+     */
+    function addBuffer($buf);
+
+    /**
+     * Is this the final frame in a fragmented message?
+     * @return bool
+     */
+    function isFinal();
+
+    /**
+     * Is the payload masked?
+     * @return bool
+     */
+    function isMasked();
+
+    /**
+     * @return int
+     */
+    function getOpcode();
+
+    /**
+     * @return int
+     */
+    //function getReceivedPayloadLength();
+
+    /**
+     * 32-big string
+     * @return string
+     */
+    function getMaskingKey();
+}
diff --git a/assets/php/vendor/ratchet/rfc6455/src/Messaging/Message.php b/assets/php/vendor/ratchet/rfc6455/src/Messaging/Message.php
new file mode 100644
index 0000000..4f3b014
--- /dev/null
+++ b/assets/php/vendor/ratchet/rfc6455/src/Messaging/Message.php
@@ -0,0 +1,123 @@
+<?php
+namespace Ratchet\RFC6455\Messaging;
+
+class Message implements \IteratorAggregate, MessageInterface {
+    /**
+     * @var \SplDoublyLinkedList
+     */
+    private $_frames;
+
+    public function __construct() {
+        $this->_frames = new \SplDoublyLinkedList;
+    }
+
+    public function getIterator() {
+        return $this->_frames;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function count() {
+        return count($this->_frames);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isCoalesced() {
+        if (count($this->_frames) == 0) {
+            return false;
+        }
+
+        $last = $this->_frames->top();
+
+        return ($last->isCoalesced() && $last->isFinal());
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addFrame(FrameInterface $fragment) {
+        $this->_frames->push($fragment);
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getOpcode() {
+        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() {
+        $len = 0;
+
+        foreach ($this->_frames as $frame) {
+            try {
+                $len += $frame->getPayloadLength();
+            } catch (\UnderflowException $e) {
+                // Not an error, want the current amount buffered
+            }
+        }
+
+        return $len;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPayload() {
+        if (!$this->isCoalesced()) {
+            throw new \UnderflowException('Message has not been put back together yet');
+        }
+
+        return $this->__toString();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getContents() {
+        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() {
+        $buffer = '';
+
+        foreach ($this->_frames as $frame) {
+            $buffer .= $frame->getPayload();
+        }
+
+        return $buffer;
+    }
+
+    /**
+     * @return boolean
+     */
+    public function isBinary() {
+        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();
+    }
+}
diff --git a/assets/php/vendor/ratchet/rfc6455/src/Messaging/MessageBuffer.php b/assets/php/vendor/ratchet/rfc6455/src/Messaging/MessageBuffer.php
new file mode 100644
index 0000000..07ff4f1
--- /dev/null
+++ b/assets/php/vendor/ratchet/rfc6455/src/Messaging/MessageBuffer.php
@@ -0,0 +1,231 @@
+<?php
+namespace Ratchet\RFC6455\Messaging;
+
+class MessageBuffer {
+    /**
+     * @var \Ratchet\RFC6455\Messaging\CloseFrameChecker
+     */
+    private $closeFrameChecker;
+
+    /**
+     * @var callable
+     */
+    private $exceptionFactory;
+
+    /**
+     * @var \Ratchet\RFC6455\Messaging\Message
+     */
+    private $messageBuffer;
+
+    /**
+     * @var \Ratchet\RFC6455\Messaging\Frame
+     */
+    private $frameBuffer;
+
+    /**
+     * @var callable
+     */
+    private $onMessage;
+
+    /**
+     * @var callable
+     */
+    private $onControl;
+
+    /**
+     * @var bool
+     */
+    private $checkForMask;
+
+    function __construct(
+        CloseFrameChecker $frameChecker,
+        callable $onMessage,
+        callable $onControl = null,
+        $expectMask = true,
+        $exceptionFactory = null
+    ) {
+        $this->closeFrameChecker = $frameChecker;
+        $this->checkForMask = (bool)$expectMask;
+
+        $this->exceptionFactory ?: $this->exceptionFactory = function($msg) {
+            return new \UnderflowException($msg);
+        };
+
+        $this->onMessage = $onMessage;
+        $this->onControl = $onControl ?: function() {};
+    }
+
+    public function onData($data) {
+        while (strlen($data) > 0) {
+            $data = $this->processData($data);
+        }
+    }
+
+    /**
+     * @param string $data
+     * @return null
+     */
+    private function processData($data) {
+        $this->messageBuffer ?: $this->messageBuffer = $this->newMessage();
+        $this->frameBuffer   ?: $this->frameBuffer   = $this->newFrame();
+
+        $this->frameBuffer->addBuffer($data);
+        if (!$this->frameBuffer->isCoalesced()) {
+            return '';
+        }
+
+        $onMessage = $this->onMessage;
+        $onControl = $this->onControl;
+
+        $this->frameBuffer = $this->frameCheck($this->frameBuffer);
+
+        $overflow = $this->frameBuffer->extractOverflow();
+        $this->frameBuffer->unMaskPayload();
+
+        $opcode = $this->frameBuffer->getOpcode();
+
+        if ($opcode > 2) {
+            $onControl($this->frameBuffer);
+
+            if (Frame::OP_CLOSE === $opcode) {
+                return '';
+            }
+        } else {
+            $this->messageBuffer->addFrame($this->frameBuffer);
+        }
+
+        $this->frameBuffer = null;
+
+        if ($this->messageBuffer->isCoalesced()) {
+            $msgCheck = $this->checkMessage($this->messageBuffer);
+            if (true !== $msgCheck) {
+                $onControl($this->newCloseFrame($msgCheck, 'Ratchet detected an invalid UTF-8 payload'));
+            } else {
+                $onMessage($this->messageBuffer);
+            }
+
+            $this->messageBuffer = null;
+        }
+
+        return $overflow;
+    }
+
+    /**
+     * Check a frame to be added to the current message buffer
+     * @param \Ratchet\RFC6455\Messaging\FrameInterface|FrameInterface $frame
+     * @return \Ratchet\RFC6455\Messaging\FrameInterface|FrameInterface
+     */
+    public function frameCheck(FrameInterface $frame) {
+        if (false !== $frame->getRsv1() ||
+            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;
+                    break;
+                case Frame::OP_PING:
+                case Frame::OP_PONG:
+                    break;
+                default:
+                    return $this->newCloseFrame(Frame::CLOSE_PROTOCOL, 'Ratchet detected an invalid OP code');
+                    break;
+            }
+
+            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 \Ratchet\RFC6455\Messaging\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) {
+        if (extension_loaded('mbstring')) {
+            return mb_check_encoding($string, 'UTF-8');
+        }
+
+        return preg_match('//u', $string);
+    }
+
+    /**
+     * @return \Ratchet\RFC6455\Messaging\MessageInterface
+     */
+    public function newMessage() {
+        return new Message;
+    }
+
+    /**
+     * @param string|null $payload
+     * @param bool|null   $final
+     * @param int|null    $opcode
+     * @return \Ratchet\RFC6455\Messaging\FrameInterface
+     */
+    public function newFrame($payload = null, $final = null, $opcode = null) {
+        return new Frame($payload, $final, $opcode, $this->exceptionFactory);
+    }
+
+    public function newCloseFrame($code, $reason = '') {
+        return $this->newFrame(pack('n', $code) . $reason, true, Frame::OP_CLOSE);
+    }
+}
diff --git a/assets/php/vendor/ratchet/rfc6455/src/Messaging/MessageInterface.php b/assets/php/vendor/ratchet/rfc6455/src/Messaging/MessageInterface.php
new file mode 100644
index 0000000..fd7212e
--- /dev/null
+++ b/assets/php/vendor/ratchet/rfc6455/src/Messaging/MessageInterface.php
@@ -0,0 +1,20 @@
+<?php
+namespace Ratchet\RFC6455\Messaging;
+
+interface MessageInterface extends DataInterface, \Traversable, \Countable {
+    /**
+     * @param FrameInterface $fragment
+     * @return MessageInterface
+     */
+    function addFrame(FrameInterface $fragment);
+
+    /**
+     * @return int
+     */
+    function getOpcode();
+
+    /**
+     * @return bool
+     */
+    function isBinary();
+}