Revision control
Copy as Markdown
// Copyright (C) 2016 Kurt Pattyn <pattyn.kurt@gmail.com>.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:critical reason:network-protocol
/*!
\class QWebSocketDataProcessor
The class QWebSocketDataProcessor is responsible for reading, validating and
interpreting data from a WebSocket.
It reads data from a QIODevice, validates it against \l{RFC 6455}, and parses it into
frames (data, control).
It emits signals that correspond to the type of the frame: textFrameReceived(),
binaryFrameReceived(), textMessageReceived(), binaryMessageReceived(), pingReceived(),
pongReceived() and closeReceived().
Whenever an error is detected, the errorEncountered() signal is emitted.
QWebSocketDataProcessor also checks if a frame is allowed in a sequence of frames
(e.g. a continuation frame cannot follow a final frame).
This class is an internal class used by QWebSocketInternal for data processing and validation.
\sa Frame()
\internal
*/
#include "qwebsocketdataprocessor_p.h"
#include "qwebsocketprotocol.h"
#include "qwebsocketprotocol_p.h"
#include "qwebsocketframe_p.h"
#include <QtCore/QtEndian>
#include <QtCore/QDebug>
#include <QtCore/QIODevice>
#include <QtCore/QStringDecoder>
#include <limits.h>
QT_BEGIN_NAMESPACE
/*!
\internal
*/
QWebSocketDataProcessor::QWebSocketDataProcessor(QObject *parent) :
QObject(parent),
m_processingState(PS_READ_HEADER),
m_isFinalFrame(false),
m_isFragmented(false),
m_opCode(QWebSocketProtocol::OpCodeClose),
m_isControlFrame(false),
m_hasMask(false),
m_mask(0),
m_payloadLength(0),
m_decoder(QStringDecoder(QStringDecoder::Utf8, QStringDecoder::Flag::ConvertInvalidToNull)),
m_waitTimer(new QChronoTimer(this))
{
clear();
// initialize the internal timeout timer
using namespace std::chrono_literals;
m_waitTimer->setInterval(5s);
m_waitTimer->setSingleShot(true);
m_waitTimer->callOnTimeout(this, &QWebSocketDataProcessor::timeout);
}
/*!
\internal
*/
QWebSocketDataProcessor::~QWebSocketDataProcessor()
{
clear();
}
void QWebSocketDataProcessor::setMaxAllowedFrameSize(quint64 maxAllowedFrameSize)
{
frame.setMaxAllowedFrameSize(maxAllowedFrameSize);
}
quint64 QWebSocketDataProcessor::maxAllowedFrameSize() const
{
return frame.maxAllowedFrameSize();
}
/*!
\internal
*/
void QWebSocketDataProcessor::setMaxAllowedMessageSize(quint64 maxAllowedMessageSize)
{
if (maxAllowedMessageSize <= maxMessageSize())
m_maxAllowedMessageSize = maxAllowedMessageSize;
}
/*!
\internal
*/
quint64 QWebSocketDataProcessor::maxAllowedMessageSize() const
{
return m_maxAllowedMessageSize;
}
/*!
\internal
*/
quint64 QWebSocketDataProcessor::maxMessageSize()
{
return MAX_MESSAGE_SIZE_IN_BYTES; //COV_NF_LINE
}
/*!
\internal
*/
quint64 QWebSocketDataProcessor::maxFrameSize()
{
return QWebSocketFrame::maxFrameSize();
}
/*!
\internal
*/
void QWebSocketDataProcessor::setIdleTimeout(std::chrono::milliseconds timeout)
{
Q_ASSERT(!m_waitTimer->isActive());
m_waitTimer->setInterval(timeout);
}
/*!
\internal
*/
std::chrono::milliseconds QWebSocketDataProcessor::idleTimeout() const
{
using namespace std::chrono;
return duration_cast<milliseconds>(m_waitTimer->interval());
}
/*!
\internal
Returns \c true if a complete websocket frame has been processed;
otherwise returns \c false.
*/
bool QWebSocketDataProcessor::process(QIODevice *pIoDevice)
{
if (Q_UNLIKELY(m_hasFailed))
return false;
bool isDone = false;
while (!isDone) {
frame.readFrame(pIoDevice);
if (!frame.isDone()) {
// waiting for more data available
QObject::connect(pIoDevice, &QIODevice::readyRead,
m_waitTimer, &QChronoTimer::stop, Qt::UniqueConnection);
m_waitTimer->start();
return false;
} else if (Q_LIKELY(frame.isValid())) {
if (frame.isControlFrame()) {
isDone = processControlFrame(frame);
} else {
//we have a dataframe; opcode can be OC_CONTINUE, OC_TEXT or OC_BINARY
if (Q_UNLIKELY(!m_isFragmented && frame.isContinuationFrame())) {
reportError(QWebSocketProtocol::CloseCodeProtocolError,
tr("Received Continuation frame, while there is " \
"nothing to continue."));
return false;
}
if (Q_UNLIKELY(m_isFragmented && frame.isDataFrame() &&
!frame.isContinuationFrame())) {
reportError(QWebSocketProtocol::CloseCodeProtocolError,
tr("All data frames after the initial data frame " \
"must have opcode 0 (continuation)."));
return false;
}
if (!frame.isContinuationFrame()) {
m_opCode = frame.opCode();
m_isFragmented = !frame.isFinalFrame();
}
quint64 messageLength = m_opCode == QWebSocketProtocol::OpCodeText
? quint64(m_textMessage.size())
: quint64(m_binaryMessage.size());
if (Q_UNLIKELY((messageLength + quint64(frame.payload().size())) >
maxAllowedMessageSize())) {
reportError(QWebSocketProtocol::CloseCodeTooMuchData,
tr("Received message is too big."));
return false;
}
bool isFinalFrame = frame.isFinalFrame();
if (m_opCode == QWebSocketProtocol::OpCodeText) {
QString frameTxt = m_decoder(frame.payload());
bool decoderHadError = m_decoder.hasError();
if (!decoderHadError && isFinalFrame) {
auto r = m_decoder.finalize();
decoderHadError = r.error != QStringDecoder::FinalizeResult::Error::NoError;
}
if (Q_UNLIKELY(decoderHadError)) {
reportError(QWebSocketProtocol::CloseCodeWrongDatatype,
tr("Invalid UTF-8 code encountered."));
return false;
} else {
m_textMessage.append(frameTxt);
frame.clear();
Q_EMIT textFrameReceived(frameTxt, isFinalFrame);
}
} else {
m_binaryMessage.append(frame.payload());
QByteArray payload = frame.payload();
frame.clear();
Q_EMIT binaryFrameReceived(payload, isFinalFrame);
}
if (isFinalFrame) {
isDone = true;
if (m_opCode == QWebSocketProtocol::OpCodeText) {
const QString textMessage(m_textMessage);
clear();
Q_EMIT textMessageReceived(textMessage);
} else {
const QByteArray binaryMessage(m_binaryMessage);
clear();
Q_EMIT binaryMessageReceived(binaryMessage);
}
}
}
} else {
reportError(frame.closeCode(), frame.closeReason());
return false;
}
frame.clear();
}
return true;
}
/*!
\internal
*/
void QWebSocketDataProcessor::clear()
{
m_processingState = PS_READ_HEADER;
m_isFinalFrame = false;
m_isFragmented = false;
m_opCode = QWebSocketProtocol::OpCodeClose;
m_hasMask = false;
m_mask = 0;
m_binaryMessage.clear();
m_textMessage.clear();
m_payloadLength = 0;
m_decoder.resetState();
m_hasFailed = false;
frame.clear();
}
/*!
\internal
Reports a protocol violation and marks the connection as failed, so that no
further data is parsed after the error.
*/
void QWebSocketDataProcessor::reportError(QWebSocketProtocol::CloseCode code,
const QString &description)
{
clear();
m_hasFailed = true;
Q_EMIT errorEncountered(code, description);
}
/*!
\internal
*/
bool QWebSocketDataProcessor::processControlFrame(const QWebSocketFrame &frame)
{
bool mustStopProcessing = true; //control frames never expect additional frames to be processed
switch (frame.opCode()) {
case QWebSocketProtocol::OpCodePing:
Q_EMIT pingReceived(frame.payload());
break;
case QWebSocketProtocol::OpCodePong:
Q_EMIT pongReceived(frame.payload());
break;
case QWebSocketProtocol::OpCodeClose:
{
quint16 closeCode = QWebSocketProtocol::CloseCodeNormal;
QString closeReason;
QByteArray payload = frame.payload();
if (Q_UNLIKELY(payload.size() == 1)) {
//size is either 0 (no close code and no reason)
//or >= 2 (at least a close code of 2 bytes)
closeCode = QWebSocketProtocol::CloseCodeProtocolError;
closeReason = tr("Payload of close frame is too small.");
} else if (Q_LIKELY(payload.size() > 1)) {
//close frame can have a close code and reason
closeCode = qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(payload.constData()));
if (Q_UNLIKELY(!QWebSocketProtocol::isCloseCodeValid(closeCode))) {
closeCode = QWebSocketProtocol::CloseCodeProtocolError;
closeReason = tr("Invalid close code %1 detected.").arg(closeCode);
} else {
if (payload.size() > 2) {
auto toUtf16 = QStringDecoder(QStringDecoder::Utf8,
QStringDecoder::Flag::Stateless | QStringDecoder::Flag::ConvertInvalidToNull);
closeReason = toUtf16(QByteArrayView(payload).sliced(2));
if (Q_UNLIKELY(toUtf16.hasError())) {
closeCode = QWebSocketProtocol::CloseCodeWrongDatatype;
closeReason = tr("Invalid UTF-8 code encountered.");
}
}
}
}
Q_EMIT closeReceived(static_cast<QWebSocketProtocol::CloseCode>(closeCode), closeReason);
break;
}
case QWebSocketProtocol::OpCodeContinue:
case QWebSocketProtocol::OpCodeBinary:
case QWebSocketProtocol::OpCodeText:
case QWebSocketProtocol::OpCodeReserved3:
case QWebSocketProtocol::OpCodeReserved4:
case QWebSocketProtocol::OpCodeReserved5:
case QWebSocketProtocol::OpCodeReserved6:
case QWebSocketProtocol::OpCodeReserved7:
case QWebSocketProtocol::OpCodeReservedC:
case QWebSocketProtocol::OpCodeReservedB:
case QWebSocketProtocol::OpCodeReservedD:
case QWebSocketProtocol::OpCodeReservedE:
case QWebSocketProtocol::OpCodeReservedF:
//do nothing
//case statements added to make C++ compiler happy
break;
default:
Q_EMIT errorEncountered(QWebSocketProtocol::CloseCodeProtocolError,
tr("Invalid opcode detected: %1").arg(int(frame.opCode())));
//do nothing
break;
}
return mustStopProcessing;
}
/*!
\internal
*/
void QWebSocketDataProcessor::timeout()
{
reportError(QWebSocketProtocol::CloseCodeGoingAway,
tr("Timeout when reading data from socket."));
}
QT_END_NAMESPACE