Revision control
// 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
#include "qwebsocket.h"
#include "qwebsocket_p.h"
#include "qwebsocketprotocol_p.h"
#include "qwebsockethandshakerequest_p.h"
#include "qwebsockethandshakeresponse_p.h"
#include "qdefaultmaskgenerator_p.h"
#include <QtCore/QCoreApplication>
#include <QtCore/QUrl>
#include <QtNetwork/QAuthenticator>
#include <QtNetwork/QTcpSocket>
#include <QtCore/QByteArray>
#include <QtCore/QtEndian>
#include <QtCore/QCryptographicHash>
#include <QtCore/QRegularExpression>
#include <QtCore/QStringList>
#include <QtNetwork/QHostAddress>
#include <QtCore/QStringBuilder> //for more efficient string concatenation
#ifndef QT_NONETWORKPROXY
#include <QtNetwork/QNetworkProxy>
#endif
#ifndef QT_NO_SSL
#include <QtNetwork/QSslConfiguration>
#include <QtNetwork/QSslError>
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#endif
#include <QtNetwork/private/qhttpheaderparser_p.h>
#include <QtNetwork/private/qauthenticator_p.h>
#include <QtCore/QDebug>
#include <QtCore/QTimer>
#include <limits>
#include <memory>
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
namespace {
constexpr quint64 MAX_OUTGOING_FRAME_SIZE_IN_BYTES = std::numeric_limits<int>::max() - 1;
constexpr quint64 DEFAULT_OUTGOING_FRAME_SIZE_IN_BYTES = 512 * 512 * 2; // default size of a frame when sending a message
// Based on isSeperator() from qtbase/src/network/access/qhsts.cpp
//
// separators = "(" | ")" | "<" | ">" | "@"
// | "," | ";" | ":" | "\" | <">
// | "/" | "[" | "]" | "?" | "="
// | "{" | "}" | SP | HT
// TODO: Should probably make things like this re-usable as private API of QtNetwork
bool isSeparator(char c)
{
// separators = "(" | ")" | "<" | ">" | "@"
// | "," | ";" | ":" | "\" | <">
// | "/" | "[" | "]" | "?" | "="
// | "{" | "}" | SP | HT
static const char separators[] = "()<>@,;:\\\"/[]?={} \t";
static const char *end = separators + sizeof separators - 1;
return std::find(separators, end, c) != end;
}
// 10. The request MAY include a header field with the name
// |Sec-WebSocket-Protocol|. If present, this value indicates one
// or more comma-separated subprotocol the client wishes to speak,
// ordered by preference. The elements that comprise this value
// MUST be non-empty strings with characters in the range U+0021 to
// U+007E not including separator characters as defined in
// [RFC2616] and MUST all be unique strings.
bool isValidSubProtocolName(const QString &protocol)
{
return std::all_of(protocol.begin(), protocol.end(), [](const QChar &c) {
return c.unicode() >= 0x21 && c.unicode() <= 0x7E && !isSeparator(c.toLatin1());
});
}
}
QWebSocketConfiguration::QWebSocketConfiguration() :
#ifndef QT_NO_SSL
m_sslConfiguration(QSslConfiguration::defaultConfiguration()),
m_ignoredSslErrors(),
m_ignoreSslErrors(false),
#endif
#ifndef QT_NO_NETWORKPROXY
m_proxy(QNetworkProxy::DefaultProxy),
#endif
m_pSocket(nullptr)
{
}
/*!
\internal
*/
QWebSocketPrivate::QWebSocketPrivate(const QString &origin, QWebSocketProtocol::Version version) :
QObjectPrivate(),
m_pSocket(nullptr),
m_errorString(),
m_version(version),
m_resourceName(),
m_request(),
m_origin(origin),
m_protocol(),
m_extension(),
m_socketState(QAbstractSocket::UnconnectedState),
m_pauseMode(QAbstractSocket::PauseNever),
m_readBufferSize(0),
m_key(),
m_mustMask(true),
m_isClosingHandshakeSent(false),
m_isClosingHandshakeReceived(false),
m_closeCode(QWebSocketProtocol::CloseCodeNormal),
m_closeReason(),
m_pingTimer(),
m_configuration(),
m_pMaskGenerator(&m_defaultMaskGenerator),
m_defaultMaskGenerator(),
m_outgoingFrameSize(DEFAULT_OUTGOING_FRAME_SIZE_IN_BYTES)
{
m_pingTimer.start();
}
/*!
\internal
*/
QWebSocketPrivate::QWebSocketPrivate(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version) :
QObjectPrivate(),
m_pSocket(pTcpSocket),
m_errorString(pTcpSocket->errorString()),
m_version(version),
m_resourceName(),
m_request(),
m_origin(),
m_protocol(),
m_extension(),
m_socketState(pTcpSocket->state()),
m_pauseMode(pTcpSocket->pauseMode()),
m_readBufferSize(pTcpSocket->readBufferSize()),
m_key(),
m_mustMask(true),
m_isClosingHandshakeSent(false),
m_isClosingHandshakeReceived(false),
m_closeCode(QWebSocketProtocol::CloseCodeNormal),
m_closeReason(),
m_pingTimer(),
m_configuration(),
m_pMaskGenerator(&m_defaultMaskGenerator),
m_defaultMaskGenerator(),
m_outgoingFrameSize(DEFAULT_OUTGOING_FRAME_SIZE_IN_BYTES)
{
m_pingTimer.start();
}
/*!
\internal
*/
void QWebSocketPrivate::init()
{
Q_ASSERT(q_ptr);
Q_ASSERT(m_pMaskGenerator);
m_dataProcessor->setParent(q_ptr);
m_pMaskGenerator->seed();
if (m_pSocket) {
makeConnections(m_pSocket);
}
}
/*!
\internal
*/
QWebSocketPrivate::~QWebSocketPrivate()
{
#ifdef Q_OS_WASM
if (m_socketContext) {
uint16_t m_readyState;
emscripten_websocket_get_ready_state(m_socketContext, &m_readyState);
if (m_readyState == 1 || m_readyState == 0) {
emscripten_websocket_close(m_socketContext, 1000,"");
}
emscripten_websocket_delete(m_socketContext);
}
#endif
}
/*!
\internal
*/
void QWebSocketPrivate::closeGoingAway()
{
if (!m_pSocket)
return;
if (state() == QAbstractSocket::ConnectedState)
close(QWebSocketProtocol::CloseCodeGoingAway, QWebSocket::tr("Connection closed"));
releaseConnections(m_pSocket);
}
/*!
\internal
*/
void QWebSocketPrivate::abort()
{
if (m_pSocket)
m_pSocket->abort();
}
/*!
\internal
*/
QAbstractSocket::SocketError QWebSocketPrivate::error() const
{
QAbstractSocket::SocketError err = QAbstractSocket::UnknownSocketError;
if (Q_LIKELY(m_pSocket))
err = m_pSocket->error();
return err;
}
/*!
\internal
*/
QString QWebSocketPrivate::errorString() const
{
QString errMsg;
if (!m_errorString.isEmpty())
errMsg = m_errorString;
else if (m_pSocket)
errMsg = m_pSocket->errorString();
return errMsg;
}
/*!
\internal
*/
bool QWebSocketPrivate::flush()
{
bool result = true;
if (Q_LIKELY(m_pSocket))
result = m_pSocket->flush();
return result;
}
#ifndef Q_OS_WASM
/*!
\internal
*/
qint64 QWebSocketPrivate::sendTextMessage(const QString &message)
{
return doWriteFrames(message.toUtf8(), false);
}
/*!
\internal
*/
qint64 QWebSocketPrivate::sendBinaryMessage(const QByteArray &data)
{
return doWriteFrames(data, true);
}
#endif
#ifndef QT_NO_SSL
/*!
\internal
*/
void QWebSocketPrivate::setSslConfiguration(const QSslConfiguration &sslConfiguration)
{
m_configuration.m_sslConfiguration = sslConfiguration;
}
/*!
\internal
*/
QSslConfiguration QWebSocketPrivate::sslConfiguration() const
{
return m_configuration.m_sslConfiguration;
}
/*!
\internal
*/
void QWebSocketPrivate::ignoreSslErrors(const QList<QSslError> &errors)
{
m_configuration.m_ignoredSslErrors = errors;
if (Q_LIKELY(m_pSocket)) {
QSslSocket *pSslSocket = qobject_cast<QSslSocket *>(m_pSocket);
// AXIVION DISABLE Qt-Security-QSslSocketIgnoreSslErrors: intentional behavior
if (Q_LIKELY(pSslSocket))
pSslSocket->ignoreSslErrors(errors);
// AXIVION ENABLE Qt-Security-QSslSocketIgnoreSslErrors
}
}
/*!
* \internal
*/
void QWebSocketPrivate::ignoreSslErrors()
{
m_configuration.m_ignoreSslErrors = true;
if (Q_LIKELY(m_pSocket)) {
QSslSocket *pSslSocket = qobject_cast<QSslSocket *>(m_pSocket);
// AXIVION DISABLE Qt-Security-QSslSocketIgnoreSslErrors: intentional behavior
if (Q_LIKELY(pSslSocket))
pSslSocket->ignoreSslErrors();
// AXIVION ENABLE Qt-Security-QSslSocketIgnoreSslErrors
}
}
/*!
* \internal
*/
void QWebSocketPrivate::continueInterruptedHandshake()
{
if (Q_LIKELY(m_pSocket)) {
QSslSocket *pSslSocket = qobject_cast<QSslSocket *>(m_pSocket);
if (Q_LIKELY(pSslSocket))
pSslSocket->continueInterruptedHandshake();
}
}
/*!
* \internal
*/
void QWebSocketPrivate::_q_updateSslConfiguration()
{
if (QSslSocket *sslSock = qobject_cast<QSslSocket *>(m_pSocket))
m_configuration.m_sslConfiguration = sslSock->sslConfiguration();
}
#endif
QStringList QWebSocketPrivate::requestedSubProtocols() const
{
auto subprotocolsRequestedInRawHeader = [this]() {
QStringList protocols;
QByteArrayView rawProtocols = m_request.headers().value("Sec-WebSocket-Protocol");
QLatin1StringView rawProtocolsView(rawProtocols);
const QStringList &optionsProtocols = m_options.subprotocols();
for (auto &&entry : rawProtocolsView.tokenize(u',', Qt::SkipEmptyParts)) {
if (QLatin1StringView trimmed = entry.trimmed(); !trimmed.isEmpty()) {
if (!optionsProtocols.contains(trimmed))
protocols << trimmed;
}
}
return protocols;
};
return m_options.subprotocols() + subprotocolsRequestedInRawHeader();
}
/*!
Called from QWebSocketServer
\internal
*/
QWebSocket *QWebSocketPrivate::upgradeFrom(QTcpSocket *pTcpSocket,
const QWebSocketHandshakeRequest &request,
const QWebSocketHandshakeResponse &response,
QObject *parent)
{
QWebSocket *pWebSocket = new QWebSocket(pTcpSocket, response.acceptedVersion(), parent);
if (Q_LIKELY(pWebSocket)) {
QNetworkRequest netRequest(request.requestUrl());
netRequest.setHeaders(request.headers());
#ifndef QT_NO_SSL
if (QSslSocket *sslSock = qobject_cast<QSslSocket *>(pTcpSocket))
pWebSocket->setSslConfiguration(sslSock->sslConfiguration());
#endif
QWebSocketHandshakeOptions options;
options.setSubprotocols(request.protocols());
pWebSocket->d_func()->setExtension(response.acceptedExtension());
pWebSocket->d_func()->setOrigin(request.origin());
pWebSocket->d_func()->setRequest(netRequest, options);
pWebSocket->d_func()->setProtocol(response.acceptedProtocol());
pWebSocket->d_func()->setResourceName(request.requestUrl().toString(QUrl::RemoveUserInfo));
//a server should not send masked frames
pWebSocket->d_func()->enableMasking(false);
}
return pWebSocket;
}
#ifndef Q_OS_WASM
/*!
\internal
*/
void QWebSocketPrivate::close(QWebSocketProtocol::CloseCode closeCode, QString reason)
{
doClose(closeCode, reason, false);
}
- /*!
- \internal
-
- Sends the Close frame and then either closes the connection or waits for the
- peer to do so. \a isFailed tells whether we are failing the connection as
- described in RFC 6455 paragraph 7.1.7, in which case the transport is closed
- right away instead.
- */
- void QWebSocketPrivate::doClose(QWebSocketProtocol::CloseCode closeCode,
- QString reason, bool isFailed)
- {
- if (Q_UNLIKELY(!m_pSocket))
- return;
- Q_Q(QWebSocket);
- if (!m_isClosingHandshakeSent) {
- m_closeCode = closeCode;
- // 125 is the maximum length of a control frame, and 2 bytes are used for the close code:
- const QByteArray reasonUtf8 = reason.toUtf8().left(123);
- m_closeReason = QString::fromUtf8(reasonUtf8);
- const quint16 code = qToBigEndian<quint16>(closeCode);
- QByteArray payload;
- payload.append(static_cast<const char *>(static_cast<const void *>(&code)), 2);
- if (!reasonUtf8.isEmpty())
- payload.append(reasonUtf8);
- quint32 maskingKey = 0;
- if (m_mustMask) {
- maskingKey = generateMaskingKey();
- QWebSocketProtocol::mask(payload.data(), quint64(payload.size()), maskingKey);
- }
- QByteArray frame = getFrameHeader(QWebSocketProtocol::OpCodeClose,
- quint64(payload.size()), maskingKey, true);
-
- Q_ASSERT(payload.size() <= 125);
- frame.append(payload);
- m_pSocket->write(frame);
- m_pSocket->flush();
-
- m_isClosingHandshakeSent = true;
-
- Q_EMIT q->aboutToClose();
- }
-
- static constexpr auto closeTimerName = "_closeTimer"_L1;
- const bool waitForPeer = !m_isClosingHandshakeReceived && !isFailed;
- if (waitForPeer) {
- if (q->findChild<QTimer *>(closeTimerName))
- return;
- QTimer *closeTimer = new QTimer(q);
- closeTimer->setObjectName(closeTimerName);
- closeTimer->setInterval(3000);
- closeTimer->setSingleShot(true);
- QObject::connect(q, &QWebSocket::disconnected, closeTimer, &QTimer::stop);
- QObject::connect(q, &QWebSocket::disconnected, closeTimer, &QTimer::deleteLater);
- QObject::connect(closeTimer, &QTimer::timeout, m_pSocket, &QTcpSocket::close);
- QObject::connect(closeTimer, &QTimer::timeout, closeTimer, &QTimer::deleteLater);
- closeTimer->start();
- } else {
- m_pSocket->close();
- if (QTimer *closeTimer = q->findChild<QTimer *>(closeTimerName)) {
- closeTimer->stop();
- delete closeTimer;
- }
- }
- }
-
/*!
\internal
*/
void QWebSocketPrivate::open(const QNetworkRequest &request,
const QWebSocketHandshakeOptions &options, bool mask)
{
//just delete the old socket for the moment;
//later, we can add more 'intelligent' handling by looking at the URL
Q_Q(QWebSocket);
QUrl url = request.url();
if (!url.isValid() || url.toString().contains(QStringLiteral("\r\n"))) {
setErrorString(QWebSocket::tr("Invalid URL."));
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
return;
}
if (m_pSocket) {
releaseConnections(m_pSocket);
m_pSocket->deleteLater();
m_pSocket = nullptr;
}
//if (m_url != url)
if (Q_LIKELY(!m_pSocket)) {
m_dataProcessor->clear();
m_isClosingHandshakeReceived = false;
m_isClosingHandshakeSent = false;
m_authenticator = QAuthenticator();
m_bytesToSkipBeforeNewResponse = 0;
m_needsResendWithCredentials = false;
m_needsReconnect = false;
setRequest(request, options);
if (url.path().isEmpty())
url.setPath(QStringLiteral("/"));
QString resourceName = url.path(QUrl::FullyEncoded);
// Check for encoded \r\n
if (resourceName.contains(QStringLiteral("%0D%0A"))) {
setRequest(QNetworkRequest()); //clear request
setErrorString(QWebSocket::tr("Invalid resource name."));
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
return;
}
if (!url.query().isEmpty()) {
if (!resourceName.endsWith(QChar::fromLatin1('?'))) {
resourceName.append(QChar::fromLatin1('?'));
}
resourceName.append(url.query(QUrl::FullyEncoded));
}
if (resourceName.isEmpty())
resourceName = QStringLiteral("/");
setResourceName(resourceName);
enableMasking(mask);
#ifndef QT_NO_SSL
if (url.scheme() == QStringLiteral("wss")) {
if (!QSslSocket::supportsSsl()) {
const QString message =
QWebSocket::tr("SSL Sockets are not supported on this platform.");
setErrorString(message);
emitErrorOccurred(QAbstractSocket::UnsupportedSocketOperationError);
} else {
QSslSocket *sslSocket = new QSslSocket(q);
m_pSocket = sslSocket;
if (Q_LIKELY(m_pSocket)) {
QObject::connect(sslSocket, &QSslSocket::connected, sslSocket, [sslSocket]() {
sslSocket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
sslSocket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
});
m_pSocket->setReadBufferSize(m_readBufferSize);
m_pSocket->setPauseMode(m_pauseMode);
makeConnections(m_pSocket);
setSocketState(QAbstractSocket::ConnectingState);
sslSocket->setSslConfiguration(m_configuration.m_sslConfiguration);
if (!request.peerVerifyName().isEmpty())
sslSocket->setPeerVerifyName(request.peerVerifyName());
// AXIVION DISABLE Qt-Security-QSslSocketIgnoreSslErrors: intentional behavior
if (Q_UNLIKELY(m_configuration.m_ignoreSslErrors))
sslSocket->ignoreSslErrors();
else
sslSocket->ignoreSslErrors(m_configuration.m_ignoredSslErrors);
// AXIVION ENABLE Qt-Security-QSslSocketIgnoreSslErrors
#ifndef QT_NO_NETWORKPROXY
sslSocket->setProxy(m_configuration.m_proxy);
m_pSocket->setProtocolTag(QStringLiteral("https"));
#endif
sslSocket->connectToHostEncrypted(url.host(), quint16(url.port(443)));
} else {
const QString message = QWebSocket::tr("Out of memory.");
setErrorString(message);
emitErrorOccurred(QAbstractSocket::SocketResourceError);
}
}
} else
#endif
if (url.scheme() == QStringLiteral("ws")) {
m_pSocket = new QTcpSocket(q);
if (Q_LIKELY(m_pSocket)) {
QObject::connect(m_pSocket, &QTcpSocket::connected, m_pSocket, [this](){
m_pSocket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
m_pSocket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
});
m_pSocket->setReadBufferSize(m_readBufferSize);
m_pSocket->setPauseMode(m_pauseMode);
makeConnections(m_pSocket);
setSocketState(QAbstractSocket::ConnectingState);
#ifndef QT_NO_NETWORKPROXY
m_pSocket->setProxy(m_configuration.m_proxy);
m_pSocket->setProtocolTag(QStringLiteral("http"));
#endif
m_pSocket->connectToHost(url.host(), quint16(url.port(80)));
} else {
const QString message = QWebSocket::tr("Out of memory.");
setErrorString(message);
emitErrorOccurred(QAbstractSocket::SocketResourceError);
}
} else {
const QString message =
QWebSocket::tr("Unsupported WebSocket scheme: %1").arg(url.scheme());
setErrorString(message);
emitErrorOccurred(QAbstractSocket::UnsupportedSocketOperationError);
}
}
}
#endif
/*!
\internal
*/
void QWebSocketPrivate::ping(const QByteArray &payload)
{
QByteArray payloadTruncated = payload.left(125);
m_pingTimer.start();
quint32 maskingKey = 0;
if (m_mustMask)
maskingKey = generateMaskingKey();
QByteArray pingFrame = getFrameHeader(QWebSocketProtocol::OpCodePing,
quint64(payloadTruncated.size()),
maskingKey, true);
if (m_mustMask)
QWebSocketProtocol::mask(&payloadTruncated, maskingKey);
pingFrame.append(payloadTruncated);
qint64 ret = writeFrame(pingFrame);
Q_UNUSED(ret);
}
/*!
\internal
Sets the version to use for the WebSocket protocol;
this must be set before the socket is opened.
*/
void QWebSocketPrivate::setVersion(QWebSocketProtocol::Version version)
{
if (m_version != version)
m_version = version;
}
/*!
\internal
Sets the resource name of the connection; must be set before the socket is openend
*/
void QWebSocketPrivate::setResourceName(const QString &resourceName)
{
if (m_resourceName != resourceName)
m_resourceName = resourceName;
}
/*!
\internal
*/
void QWebSocketPrivate::setRequest(const QNetworkRequest &request,
const QWebSocketHandshakeOptions &options)
{
if (m_request != request)
m_request = request;
if (m_options != options)
m_options = options;
}
/*!
\internal
*/
void QWebSocketPrivate::setOrigin(const QString &origin)
{
if (m_origin != origin)
m_origin = origin;
}
/*!
\internal
*/
void QWebSocketPrivate::setProtocol(const QString &protocol)
{
if (m_protocol != protocol)
m_protocol = protocol;
}
/*!
\internal
*/
void QWebSocketPrivate::setExtension(const QString &extension)
{
if (m_extension != extension)
m_extension = extension;
}
/*!
\internal
*/
void QWebSocketPrivate::enableMasking(bool enable)
{
if (m_mustMask != enable)
m_mustMask = enable;
}
/*!
* \internal
*/
void QWebSocketPrivate::makeConnections(QTcpSocket *pTcpSocket)
{
Q_ASSERT(pTcpSocket);
Q_Q(QWebSocket);
if (Q_LIKELY(pTcpSocket)) {
//pass through signals
QObjectPrivate::connect(pTcpSocket, &QAbstractSocket::errorOccurred, this,
&QWebSocketPrivate::emitErrorOccurred);
#ifndef QT_NO_NETWORKPROXY
QObject::connect(pTcpSocket, &QAbstractSocket::proxyAuthenticationRequired, q,
&QWebSocket::proxyAuthenticationRequired);
#endif // QT_NO_NETWORKPROXY
QObject::connect(pTcpSocket, &QAbstractSocket::readChannelFinished, q,
&QWebSocket::readChannelFinished);
QObject::connect(pTcpSocket, &QAbstractSocket::aboutToClose, q, &QWebSocket::aboutToClose);
QObjectPrivate::connect(pTcpSocket, &QObject::destroyed,
this, &QWebSocketPrivate::socketDestroyed);
//catch signals
QObjectPrivate::connect(pTcpSocket, &QAbstractSocket::stateChanged, this,
&QWebSocketPrivate::processStateChanged);
QObjectPrivate::connect(pTcpSocket, &QAbstractSocket::readyRead, this,
&QWebSocketPrivate::processData);
#ifndef QT_NO_SSL
const QSslSocket * const sslSocket = qobject_cast<const QSslSocket *>(pTcpSocket);
if (sslSocket) {
QObject::connect(sslSocket, &QSslSocket::preSharedKeyAuthenticationRequired, q,
&QWebSocket::preSharedKeyAuthenticationRequired);
QObject::connect(sslSocket, &QSslSocket::encryptedBytesWritten, q,
&QWebSocket::bytesWritten);
QObjectPrivate::connect(sslSocket,
QOverload<const QList<QSslError>&>::of(&QSslSocket::sslErrors),
this, &QWebSocketPrivate::_q_updateSslConfiguration);
QObject::connect(sslSocket,
QOverload<const QList<QSslError>&>::of(&QSslSocket::sslErrors),
q, &QWebSocket::sslErrors);
QObjectPrivate::connect(sslSocket, &QSslSocket::encrypted,
this, &QWebSocketPrivate::_q_updateSslConfiguration);
QObject::connect(sslSocket, &QSslSocket::peerVerifyError,
q, &QWebSocket::peerVerifyError);
QObject::connect(sslSocket, &QSslSocket::alertSent,
q, &QWebSocket::alertSent);
QObject::connect(sslSocket, &QSslSocket::alertReceived,
q, &QWebSocket::alertReceived);
QObject::connect(sslSocket, &QSslSocket::handshakeInterruptedOnError,
q, &QWebSocket::handshakeInterruptedOnError);
} else
#endif // QT_NO_SSL
{
QObject::connect(pTcpSocket, &QAbstractSocket::bytesWritten, q,
&QWebSocket::bytesWritten);
}
}
QObject::connect(m_dataProcessor, &QWebSocketDataProcessor::textFrameReceived, q,
&QWebSocket::textFrameReceived);
QObject::connect(m_dataProcessor, &QWebSocketDataProcessor::binaryFrameReceived, q,
&QWebSocket::binaryFrameReceived);
QObject::connect(m_dataProcessor, &QWebSocketDataProcessor::binaryMessageReceived, q,
&QWebSocket::binaryMessageReceived);
QObject::connect(m_dataProcessor, &QWebSocketDataProcessor::textMessageReceived, q,
&QWebSocket::textMessageReceived);
QObjectPrivate::connect(m_dataProcessor, &QWebSocketDataProcessor::errorEncountered, this,
&QWebSocketPrivate::processError);
QObjectPrivate::connect(m_dataProcessor, &QWebSocketDataProcessor::pingReceived, this,
&QWebSocketPrivate::processPing);
QObjectPrivate::connect(m_dataProcessor, &QWebSocketDataProcessor::pongReceived, this,
&QWebSocketPrivate::processPong);
QObjectPrivate::connect(m_dataProcessor, &QWebSocketDataProcessor::closeReceived, this,
&QWebSocketPrivate::processClose);
//fire readyread, in case we already have data inside the tcpSocket
if (pTcpSocket->bytesAvailable())
Q_EMIT pTcpSocket->readyRead();
}
/*!
* \internal
*/
void QWebSocketPrivate::releaseConnections(const QTcpSocket *pTcpSocket)
{
if (Q_LIKELY(pTcpSocket)) {
// Explicitly disconnect this signal to avoid warning being printed about a destroyed-signal
// being disconnected with the wildcard disconnect below
disconnect(pTcpSocket, &QObject::destroyed, this, &QWebSocketPrivate::socketDestroyed);
pTcpSocket->disconnect();
// Re-connect, we need 'socketDestroyed' slot executed
QObjectPrivate::connect(pTcpSocket, &QObject::destroyed,
this, &QWebSocketPrivate::socketDestroyed);
}
m_dataProcessor->disconnect();
}
/*!
\internal
*/
QWebSocketProtocol::Version QWebSocketPrivate::version() const
{
return m_version;
}
/*!
\internal
*/
QString QWebSocketPrivate::resourceName() const
{
return m_resourceName;
}
/*!
\internal
*/
QNetworkRequest QWebSocketPrivate::request() const
{
return m_request;
}
/*!
\internal
*/
QString QWebSocketPrivate::origin() const
{
return m_origin;
}
/*!
\internal
*/
QWebSocketHandshakeOptions QWebSocketPrivate::handshakeOptions() const
{
return m_options;
}
/*!
\internal
*/
QString QWebSocketPrivate::protocol() const
{
return m_protocol;
}
/*!
\internal
*/
QString QWebSocketPrivate::extension() const
{
return m_extension;
}
/*!
* \internal
*/
QWebSocketProtocol::CloseCode QWebSocketPrivate::closeCode() const
{
return m_closeCode;
}
/*!
* \internal
*/
QString QWebSocketPrivate::closeReason() const
{
return m_closeReason;
}
/*!
* \internal
*/
QByteArray QWebSocketPrivate::getFrameHeader(QWebSocketProtocol::OpCode opCode,
quint64 payloadLength, quint32 maskingKey,
bool lastFrame)
{
QByteArray header;
bool ok = payloadLength <= 0x7FFFFFFFFFFFFFFFULL;
if (Q_LIKELY(ok)) {
//FIN, RSV1-3, opcode (RSV-1, RSV-2 and RSV-3 are zero)
quint8 byte = static_cast<quint8>((opCode & 0x0F) | (lastFrame ? 0x80 : 0x00));
header.append(static_cast<char>(byte));
byte = 0x00;
if (maskingKey != 0)
byte |= 0x80;
if (payloadLength <= 125) {
byte |= static_cast<quint8>(payloadLength);
header.append(static_cast<char>(byte));
} else if (payloadLength <= 0xFFFFU) {
byte |= 126;
header.append(static_cast<char>(byte));
quint16 swapped = qToBigEndian<quint16>(static_cast<quint16>(payloadLength));
header.append(static_cast<const char *>(static_cast<const void *>(&swapped)), 2);
} else if (payloadLength <= 0x7FFFFFFFFFFFFFFFULL) {
byte |= 127;
header.append(static_cast<char>(byte));
quint64 swapped = qToBigEndian<quint64>(payloadLength);
header.append(static_cast<const char *>(static_cast<const void *>(&swapped)), 8);
}
if (maskingKey != 0) {
const quint32 mask = qToBigEndian<quint32>(maskingKey);
header.append(static_cast<const char *>(static_cast<const void *>(&mask)),
sizeof(quint32));
}
} else {
setErrorString(QStringLiteral("WebSocket::getHeader: payload too big!"));
emitErrorOccurred(QAbstractSocket::DatagramTooLargeError);
}
return header;
}
/*!
* \internal
*/
qint64 QWebSocketPrivate::doWriteFrames(const QByteArray &data, bool isBinary)
{
qint64 payloadWritten = 0;
if (Q_UNLIKELY(!m_pSocket) || (state() != QAbstractSocket::ConnectedState))
return payloadWritten;
const QWebSocketProtocol::OpCode firstOpCode = isBinary ?
QWebSocketProtocol::OpCodeBinary : QWebSocketProtocol::OpCodeText;
int numFrames = data.size() / int(outgoingFrameSize());
QByteArray tmpData(data);
tmpData.detach();
char *payload = tmpData.data();
quint64 sizeLeft = quint64(data.size()) % outgoingFrameSize();
if (Q_LIKELY(sizeLeft))
++numFrames;
//catch the case where the payload is zero bytes;
//in this case, we still need to send a frame
if (Q_UNLIKELY(numFrames == 0))
numFrames = 1;
quint64 currentPosition = 0;
quint64 bytesLeft = quint64(data.size());
for (int i = 0; i < numFrames; ++i) {
quint32 maskingKey = 0;
if (m_mustMask)
maskingKey = generateMaskingKey();
const bool isLastFrame = (i == (numFrames - 1));
const bool isFirstFrame = (i == 0);
const quint64 size = qMin(bytesLeft, outgoingFrameSize());
const QWebSocketProtocol::OpCode opcode = isFirstFrame ? firstOpCode
: QWebSocketProtocol::OpCodeContinue;
//write header
m_pSocket->write(getFrameHeader(opcode, size, maskingKey, isLastFrame));
//write payload
if (Q_LIKELY(size > 0)) {
char *currentData = payload + currentPosition;
if (m_mustMask)
QWebSocketProtocol::mask(currentData, size, maskingKey);
qint64 written = m_pSocket->write(currentData, static_cast<qint64>(size));
if (Q_LIKELY(written > 0)) {
payloadWritten += written;
} else {
m_pSocket->flush();
setErrorString(QWebSocket::tr("Error writing bytes to socket: %1.")
.arg(m_pSocket->errorString()));
emitErrorOccurred(QAbstractSocket::NetworkError);
break;
}
}
currentPosition += size;
bytesLeft -= size;
}
if (Q_UNLIKELY(payloadWritten != data.size())) {
setErrorString(QWebSocket::tr("Bytes written %1 != %2.")
.arg(payloadWritten).arg(data.size()));
emitErrorOccurred(QAbstractSocket::NetworkError);
}
return payloadWritten;
}
/*!
\internal
*/
quint32 QWebSocketPrivate::generateMaskingKey() const
{
return m_pMaskGenerator->nextMask();
}
/*!
\internal
*/
QByteArray QWebSocketPrivate::generateKey() const
{
QByteArray key;
for (int i = 0; i < 4; ++i) {
const quint32 tmp = m_pMaskGenerator->nextMask();
key.append(static_cast<const char *>(static_cast<const void *>(&tmp)), sizeof(quint32));
}
return key.toBase64();
}
/*!
\internal
*/
QString QWebSocketPrivate::calculateAcceptKey(const QByteArray &key) const
{
const QByteArray tmpKey = key + QByteArrayLiteral("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
const QByteArray hash = QCryptographicHash::hash(tmpKey, QCryptographicHash::Sha1).toBase64();
return QString::fromLatin1(hash);
}
/*!
\internal
*/
qint64 QWebSocketPrivate::writeFrames(const QList<QByteArray> &frames)
{
qint64 written = 0;
if (Q_LIKELY(m_pSocket)) {
QList<QByteArray>::const_iterator it;
for (it = frames.cbegin(); it < frames.cend(); ++it)
written += writeFrame(*it);
}
return written;
}
/*!
\internal
*/
qint64 QWebSocketPrivate::writeFrame(const QByteArray &frame)
{
qint64 written = 0;
if (Q_LIKELY(m_pSocket))
written = m_pSocket->write(frame);
return written;
}
static QString msgUnsupportedAuthenticateChallenges(qsizetype count)
{
// Keep the error on a single line so it can easily be searched for:
//: 'WWW-Authenticate' is the HTTP header.
return count == 1
? QWebSocket::tr("QWebSocketPrivate::processHandshake: "
"Unsupported WWW-Authenticate challenge encountered.")
: QWebSocket::tr("QWebSocketPrivate::processHandshake: "
"Unsupported WWW-Authenticate challenges encountered.");
}
//called on the client for a server handshake response
/*!
\internal
*/
void QWebSocketPrivate::processHandshake(QTcpSocket *pSocket)
{
Q_Q(QWebSocket);
if (Q_UNLIKELY(!pSocket || pSocket->state() != QAbstractSocket::ConnectedState))
return;
// According to RFC822 the body is separated from the headers by a null line (CRLF)
constexpr QByteArrayView endOfHeaderMarker = "\r\n\r\n";
const qint64 maxHeaderLength = QWebSocketPrivate::MAX_HEADERLINE_LENGTH
* QWebSocketPrivate::MAX_HEADERLINES + endOfHeaderMarker.size();
// Reused by every iteration below, so a request arriving as many lines at once does
// not need a fresh buffer for each of them.
QByteArray chunk;
while (!m_preHandshakeHeaders.endsWith(endOfHeaderMarker) && pSocket->bytesAvailable() > 0) {
// readLine() writes up to maxSize - 1 bytes plus a '\0'
const qint64 maxSize = qMin(pSocket->bytesAvailable() + 1,
qint64(QWebSocketPrivate::MAX_HEADERLINE_LENGTH) + 1);
chunk.resize(maxSize);
const qint64 lineLength = pSocket->readLine(chunk.data(), maxSize);
if (Q_UNLIKELY(lineLength <= 0))
break;
//check that no one is trying to exhaust our virtual memory
if (Q_UNLIKELY(m_preHandshakeHeaders.size() + lineLength >= maxHeaderLength)) {
m_preHandshakeHeaders = {};
m_closeCode = QWebSocketProtocol::CloseCodeTooMuchData;
pSocket->close();
setErrorString(QCoreApplication::translate("QWebSocketServer", "Header is too large."));
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
return;
}
m_preHandshakeHeaders.append(chunk.constData(), lineLength);
}
if (!m_preHandshakeHeaders.endsWith(endOfHeaderMarker)) {
// The header isn't complete yet
return;
}
const QByteArray headerBuffer = std::exchange(m_preHandshakeHeaders, {});
const QByteArrayView headers = headerBuffer;
QHttpHeaderParser parser;
static const QByteArray endOfStatusMarker = QByteArrayLiteral("\r\n");
const int endOfStatusIndex = headers.indexOf(endOfStatusMarker);
const QByteArrayView status = headers.first(endOfStatusIndex);
if (!parser.parseStatus(status)) {
setErrorString(QWebSocket::tr("Read handshake request status failed"));
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
return;
}
if (!parser.parseHeaders(headers.sliced(endOfStatusIndex + endOfStatusMarker.size()))) {
setErrorString(QWebSocket::tr("Parsing handshake request header failed"));
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
return;
}
const QString acceptKey = QString::fromLatin1(parser.combinedHeaderValue(
QByteArrayLiteral("sec-websocket-accept")));
const QString upgrade = QString::fromLatin1(parser.combinedHeaderValue(
QByteArrayLiteral("upgrade")));
const QString connection = QString::fromLatin1(parser.combinedHeaderValue(
QByteArrayLiteral("connection")));
#if 0 // unused for the moment
const QString extensions = QString::fromLatin1(parser.combinedHeaderValue(
QByteArrayLiteral("sec-websocket-extensions"));
#endif
const QString protocol = QString::fromLatin1(parser.combinedHeaderValue(
QByteArrayLiteral("sec-websocket-protocol")));
if (!protocol.isEmpty() && !requestedSubProtocols().contains(protocol)) {
setErrorString(QWebSocket::tr("WebSocket server has chosen protocol %1 which has not been "
"requested")
.arg(protocol));
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
return;
}
const QString version = QString::fromLatin1(parser.combinedHeaderValue(
QByteArrayLiteral("sec-websocket-version")));
bool ok = false;
QString errorDescription;
switch (parser.getStatusCode()) {
case 101: {
//HTTP/x.y 101 Switching Protocols
//TODO: do not check the httpStatusText right now
ok = (acceptKey.size() > 0
&& parser.getMajorVersion() > 0 && parser.getMinorVersion() > 0
&& upgrade.compare(u"websocket", Qt::CaseInsensitive) == 0
&& connection.compare(u"upgrade", Qt::CaseInsensitive) == 0);
if (ok) {
const QString accept = calculateAcceptKey(m_key);
if (accept != acceptKey) {
ok = false;
errorDescription = QWebSocket::tr(
"Accept-Key received from server %1 does not match the client key %2.")
.arg(acceptKey, accept);
}
} else {
const QString upgradeParms = QLatin1String(
"Accept-key size: %1, version: %2.%3, upgrade: %4, connection: %5").arg(
QString::number(acceptKey.size()), QString::number(parser.getMajorVersion()),
QString::number(parser.getMinorVersion()), upgrade, connection);
errorDescription = QWebSocket::tr(
"Invalid parameter encountered during protocol upgrade: %1").arg(upgradeParms);
}
break;
}
case 400: {
//HTTP/1.1 400 Bad Request
if (!version.isEmpty()) {
const QStringList versions = version.split(QStringLiteral(", "), Qt::SkipEmptyParts);
if (!versions.contains(QString::number(QWebSocketProtocol::currentVersion()))) {
//if needed to switch protocol version, then we are finished here
//because we cannot handle other protocols than the RFC one (v13)
errorDescription =
QWebSocket::tr("Handshake: Server requests a version that we don't support: %1.")
.arg(versions.join(QStringLiteral(", ")));
} else {
//we tried v13, but something different went wrong
errorDescription =
QWebSocket::tr("QWebSocketPrivate::processHandshake: Unknown error condition encountered. Aborting connection.");
}
} else {
errorDescription =
QWebSocket::tr("QWebSocketPrivate::processHandshake: Unknown error condition encountered. Aborting connection.");
}
break;
}
case 401: {
// HTTP/1.1 401 UNAUTHORIZED
if (m_authenticator.isNull())
m_authenticator.detach();
auto *priv = QAuthenticatorPrivate::getPrivate(m_authenticator);
const QList<QByteArray> challenges = parser.headerFieldValues("WWW-Authenticate");
const bool isSupported = std::any_of(challenges.begin(), challenges.end(),
QAuthenticatorPrivate::isMethodSupported);
if (isSupported)
priv->parseHttpResponse(parser.headers(), /*isProxy=*/false);
if (!isSupported || priv->method == QAuthenticatorPrivate::None) {
errorDescription = msgUnsupportedAuthenticateChallenges(challenges.size());
break;
}
const QUrl url = m_request.url();
const bool hasCredentials = !url.userName().isEmpty() || !url.password().isEmpty();
if (hasCredentials) {
m_authenticator.setUser(url.userName());
m_authenticator.setPassword(url.password());
// Unset username and password so we don't try it again
QUrl copy = url;
copy.setUserName({});
copy.setPassword({});
m_request.setUrl(copy);
}
if (priv->phase == QAuthenticatorPrivate::Done) { // No user/pass from URL:
emit q->authenticationRequired(&m_authenticator);
if (priv->phase == QAuthenticatorPrivate::Done) {
// user/pass was not updated:
errorDescription = QWebSocket::tr(
"QWebSocket::processHandshake: Host requires authentication");
break;
}
}
m_needsResendWithCredentials = true;
if (parser.firstHeaderField("Connection").compare("close", Qt::CaseInsensitive) == 0)
m_needsReconnect = true;
else
m_bytesToSkipBeforeNewResponse = parser.firstHeaderField("Content-Length").toInt();
break;
}
default: {
errorDescription =
QWebSocket::tr("QWebSocketPrivate::processHandshake: Unhandled http status code: %1 (%2).")
.arg(parser.getStatusCode()).arg(parser.getReasonPhrase());
}
}
if (ok) {
// handshake succeeded
setProtocol(protocol);
setSocketState(QAbstractSocket::ConnectedState);
Q_EMIT q->connected();
} else if (m_needsResendWithCredentials) {
if (m_needsReconnect && m_pSocket->state() != QAbstractSocket::UnconnectedState) {
// Disconnect here, then in processStateChanged() we reconnect when
// we are unconnected.
m_pSocket->disconnectFromHost();
} else {
// I'm cheating, this is how a handshake starts:
processStateChanged(QAbstractSocket::ConnectedState);
}
return;
} else {
// handshake failed
setErrorString(errorDescription);
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
if (m_pSocket->state() != QAbstractSocket::UnconnectedState)
m_pSocket->disconnectFromHost();
}
}
/*!
\internal
*/
static QString removeZoneId(const QString& hostPort)
{
const auto closeBracketIndex = hostPort.indexOf(u']');
const auto percentIndex = hostPort.indexOf(u'%');
// Only perform a minimal sanity check, as at this point the
// URI parts host and port were already used successfully to
// connect to the host.
if (!hostPort.startsWith(u'[') || closeBracketIndex == -1
|| percentIndex == -1 || percentIndex > closeBracketIndex) {
return hostPort;
}
return hostPort.left(percentIndex) + hostPort.mid(closeBracketIndex);
}
/*!
\internal
*/
void QWebSocketPrivate::processStateChanged(QAbstractSocket::SocketState socketState)
{
Q_ASSERT(m_pSocket);
Q_Q(QWebSocket);
QAbstractSocket::SocketState webSocketState = this->state();
switch (socketState) {
case QAbstractSocket::ConnectedState:
#ifndef QT_NO_SSL
if (QSslSocket *sslSock = qobject_cast<QSslSocket *>(m_pSocket))
m_configuration.m_sslConfiguration = sslSock->sslConfiguration();
#endif
if (webSocketState == QAbstractSocket::ConnectingState) {
// Nothing from an earlier connection may be left to prepend to this one
m_preHandshakeHeaders = {};
m_key = generateKey();
QList<QPair<QString, QString> > headers;
QString hostHeaderOverride;
const auto h = m_request.headers();
for (qsizetype i = 0; i < h.size(); ++i) {
const auto name = h.nameAt(i);
const auto value = h.valueAt(i);
if (name.compare("Host", Qt::CaseInsensitive) == 0) {
hostHeaderOverride = QString::fromLatin1(value);
continue;
}
// protocols handled separately below
if (name.compare("Sec-WebSocket-Protocol", Qt::CaseInsensitive) == 0)
continue;
headers << qMakePair(QString::fromLatin1(name),
QString::fromLatin1(value));
}
const QStringList subProtocols = requestedSubProtocols();
// Perform authorization if needed:
if (m_needsResendWithCredentials) {
m_needsResendWithCredentials = false;
// Based on QHttpNetworkRequest::uri:
auto uri = [](QUrl url) -> QByteArray {
QUrl::FormattingOptions format(QUrl::RemoveFragment | QUrl::RemoveUserInfo
| QUrl::FullyEncoded);
if (url.path().isEmpty())
url.setPath(QStringLiteral("/"));
else
format |= QUrl::NormalizePathSegments;
return url.toEncoded(format);
};
auto *priv = QAuthenticatorPrivate::getPrivate(m_authenticator);
Q_ASSERT(priv);
QByteArray response = priv->calculateResponse("GET", uri(m_request.url()),
m_request.url().host());
if (!response.isEmpty())
headers << qMakePair(u"Authorization"_s, QString::fromLatin1(response));
}
const auto format = QUrl::RemoveScheme | QUrl::RemoveUserInfo
| QUrl::RemovePath | QUrl::RemoveQuery
| QUrl::RemoveFragment;
// mid(2) removes the prefix "//" from the remaining url
const QString host = hostHeaderOverride.isEmpty()
? removeZoneId(m_request.url().toString(format).mid(2))
: hostHeaderOverride;
const QString handshake = createHandShakeRequest(m_resourceName,
host,
origin(),
QString(),
subProtocols,
m_key,
headers);
if (handshake.isEmpty()) {
m_pSocket->abort();
emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);
return;
}
m_pSocket->write(handshake.toLatin1());
}
break;
case QAbstractSocket::ClosingState:
if (webSocketState == QAbstractSocket::ConnectedState)
setSocketState(QAbstractSocket::ClosingState);
break;
case QAbstractSocket::UnconnectedState:
m_preHandshakeHeaders = {};
if (m_needsReconnect) {
// Need to reinvoke the lambda queued because the underlying socket
// isn't done cleaning up yet...
auto reconnect = [this]() {
m_needsReconnect = false;
const QUrl url = m_request.url();
#if QT_CONFIG(ssl)
const bool isEncrypted = url.scheme().compare(u"wss", Qt::CaseInsensitive) == 0;
if (isEncrypted) {
// This has to work because we did it earlier; this is just us
// reconnecting!
auto *sslSocket = qobject_cast<QSslSocket *>(m_pSocket);
Q_ASSERT(sslSocket);
sslSocket->connectToHostEncrypted(url.host(), quint16(url.port(443)));
} else
#endif
{
m_pSocket->connectToHost(url.host(), quint16(url.port(80)));
}
};
QMetaObject::invokeMethod(q, reconnect, Qt::QueuedConnection);
} else if (webSocketState != QAbstractSocket::UnconnectedState) {
setSocketState(QAbstractSocket::UnconnectedState);
Q_EMIT q->disconnected();
}
break;
case QAbstractSocket::HostLookupState:
case QAbstractSocket::ConnectingState:
case QAbstractSocket::BoundState:
case QAbstractSocket::ListeningState:
//do nothing
//to make C++ compiler happy;
break;
}
}
+ /*!
+ \internal
+
+ Sends the Close frame and then either closes the connection or waits for the
+ peer to do so. \a isFailed tells whether we are failing the connection as
+ described in RFC 6455 paragraph 7.1.7, in which case the transport is closed
+ right away instead.
+ */
+ void QWebSocketPrivate::doClose(QWebSocketProtocol::CloseCode closeCode,
+ QString reason, bool isFailed)
+ {
+ if (Q_UNLIKELY(!m_pSocket))
+ return;
+ Q_Q(QWebSocket);
+ if (!m_isClosingHandshakeSent) {
+ m_closeCode = closeCode;
+ // 125 is the maximum length of a control frame, and 2 bytes are used for the close code:
+ const QByteArray reasonUtf8 = reason.toUtf8().left(123);
+ m_closeReason = QString::fromUtf8(reasonUtf8);
+ const quint16 code = qToBigEndian<quint16>(closeCode);
+ QByteArray payload;
+ payload.append(static_cast<const char *>(static_cast<const void *>(&code)), 2);
+ if (!reasonUtf8.isEmpty())
+ payload.append(reasonUtf8);
+ quint32 maskingKey = 0;
+ if (m_mustMask) {
+ maskingKey = generateMaskingKey();
+ QWebSocketProtocol::mask(payload.data(), quint64(payload.size()), maskingKey);
+ }
+ QByteArray frame = getFrameHeader(QWebSocketProtocol::OpCodeClose,
+ quint64(payload.size()), maskingKey, true);
+
+ Q_ASSERT(payload.size() <= 125);
+ frame.append(payload);
+ m_pSocket->write(frame);
+ m_pSocket->flush();
+
+ m_isClosingHandshakeSent = true;
+
+ Q_EMIT q->aboutToClose();
+ }
+
+ static constexpr auto closeTimerName = "_closeTimer"_L1;
+ const bool waitForPeer = !m_isClosingHandshakeReceived && !isFailed;
+ if (waitForPeer) {
+ if (q->findChild<QTimer *>(closeTimerName))
+ return;
+ QTimer *closeTimer = new QTimer(q);
+ closeTimer->setObjectName(closeTimerName);
+ closeTimer->setInterval(3000);
+ closeTimer->setSingleShot(true);
+ QObject::connect(q, &QWebSocket::disconnected, closeTimer, &QTimer::stop);
+ QObject::connect(q, &QWebSocket::disconnected, closeTimer, &QTimer::deleteLater);
+ QObject::connect(closeTimer, &QTimer::timeout, m_pSocket, &QTcpSocket::close);
+ QObject::connect(closeTimer, &QTimer::timeout, closeTimer, &QTimer::deleteLater);
+ closeTimer->start();
+ } else {
+ m_pSocket->close();
+ if (QTimer *closeTimer = q->findChild<QTimer *>(closeTimerName)) {
+ closeTimer->stop();
+ delete closeTimer;
+ }
+ }
+ }
+
void QWebSocketPrivate::socketDestroyed(QObject *socket)
{
Q_ASSERT(m_pSocket);
if (m_pSocket == socket)
m_pSocket = nullptr;
}
/*!
\internal
*/
void QWebSocketPrivate::processData()
{
if (!m_pSocket) // disconnected with data still in-bound
return;
if (state() == QAbstractSocket::ConnectingState) {
if (m_bytesToSkipBeforeNewResponse > 0)
m_bytesToSkipBeforeNewResponse -= m_pSocket->skip(m_bytesToSkipBeforeNewResponse);
if (m_bytesToSkipBeforeNewResponse > 0)
return;
processHandshake(m_pSocket);
// That may have changed state(), recheck in the next 'if' below.
}
if (state() != QAbstractSocket::ConnectingState) {
while (m_pSocket->bytesAvailable()) {
if (!m_dataProcessor->process(m_pSocket))
return;
}
}
}
/*!
\internal
*/
void QWebSocketPrivate::processPing(const QByteArray &data)
{
Q_ASSERT(m_pSocket);
quint32 maskingKey = 0;
if (m_mustMask)
maskingKey = generateMaskingKey();
m_pSocket->write(getFrameHeader(QWebSocketProtocol::OpCodePong,
unsigned(data.size()),
maskingKey,
true));
if (data.size() > 0) {
QByteArray maskedData = data;
if (m_mustMask)
QWebSocketProtocol::mask(&maskedData, maskingKey);
m_pSocket->write(maskedData);
}
}
/*!
\internal
*/
void QWebSocketPrivate::processPong(const QByteArray &data)
{
Q_Q(QWebSocket);
Q_EMIT q->pong(static_cast<quint64>(m_pingTimer.elapsed()), data);
}
/*!
\internal
*/
void QWebSocketPrivate::processClose(QWebSocketProtocol::CloseCode closeCode, QString closeReason)
{
m_isClosingHandshakeReceived = true;
close(closeCode, closeReason);
}
/*!
\internal
Fails the connection as described in RFC 6455 paragraph 7.1.7: send a Close
frame, then close the connection straight away. No reply can be processed
afterwards, so neither endpoint has anything to wait for.
*/
void QWebSocketPrivate::processError(QWebSocketProtocol::CloseCode closeCode, QString reason)
{
doClose(closeCode, reason, true);
}
/*!
\internal
*/
QString QWebSocketPrivate::createHandShakeRequest(QString resourceName,
QString host,
QString origin,
QString extensions,
const QStringList &protocols,
QByteArray key,
const QList<QPair<QString, QString> > &headers)
{
QStringList handshakeRequest;
if (resourceName.contains(QStringLiteral("\r\n"))) {
setErrorString(QWebSocket::tr("The resource name contains newlines. " \
"Possible attack detected."));
return QString();
}
if (host.contains(QStringLiteral("\r\n"))) {
setErrorString(QWebSocket::tr("The hostname contains newlines. " \
"Possible attack detected."));
return QString();
}
if (origin.contains(QStringLiteral("\r\n"))) {
setErrorString(QWebSocket::tr("The origin contains newlines. " \
"Possible attack detected."));
return QString();
}
if (extensions.contains(QStringLiteral("\r\n"))) {
setErrorString(QWebSocket::tr("The extensions attribute contains newlines. " \
"Possible attack detected."));
return QString();
}
handshakeRequest << QStringLiteral("GET ") % resourceName % QStringLiteral(" HTTP/1.1") <<
QStringLiteral("Host: ") % host <<
QStringLiteral("Upgrade: websocket") <<
QStringLiteral("Connection: Upgrade") <<
QStringLiteral("Sec-WebSocket-Key: ") % QString::fromLatin1(key);
if (!origin.isEmpty())
handshakeRequest << QStringLiteral("Origin: ") % origin;
handshakeRequest << QStringLiteral("Sec-WebSocket-Version: ")
% QString::number(QWebSocketProtocol::currentVersion());
if (extensions.size() > 0)
handshakeRequest << QStringLiteral("Sec-WebSocket-Extensions: ") % extensions;
const QStringList validProtocols = [&] {
QStringList validProtocols;
validProtocols.reserve(protocols.size());
for (const auto &p : protocols) {
if (isValidSubProtocolName(p))
validProtocols.append(p);
else
qWarning() << "Ignoring invalid WebSocket subprotocol name" << p;
}
return validProtocols;
}();
if (!validProtocols.isEmpty()) {
handshakeRequest << QStringLiteral("Sec-WebSocket-Protocol: ")
% validProtocols.join(QLatin1String(", "));
}
for (const auto &header : headers)
handshakeRequest << header.first % QStringLiteral(": ") % header.second;
handshakeRequest << QStringLiteral("\r\n");
return handshakeRequest.join(QStringLiteral("\r\n"));
}
/*!
\internal
*/
QAbstractSocket::SocketState QWebSocketPrivate::state() const
{
return m_socketState;
}
/*!
\internal
*/
void QWebSocketPrivate::setSocketState(QAbstractSocket::SocketState state)
{
Q_Q(QWebSocket);
if (m_socketState != state) {
m_socketState = state;
Q_EMIT q->stateChanged(m_socketState);
}
}
/*!
\internal
*/
void QWebSocketPrivate::setMaxAllowedIncomingFrameSize(quint64 maxAllowedIncomingFrameSize)
{
m_dataProcessor->setMaxAllowedFrameSize(maxAllowedIncomingFrameSize);
}
/*!
\internal
*/
quint64 QWebSocketPrivate::maxAllowedIncomingFrameSize() const
{
return m_dataProcessor->maxAllowedFrameSize();
}
/*!
\internal
*/
void QWebSocketPrivate::setMaxAllowedIncomingMessageSize(quint64 maxAllowedIncomingMessageSize)
{
m_dataProcessor->setMaxAllowedMessageSize(maxAllowedIncomingMessageSize);
}
/*!
\internal
*/
quint64 QWebSocketPrivate::maxAllowedIncomingMessageSize() const
{
return m_dataProcessor->maxAllowedMessageSize();
}
/*!
\internal
*/
quint64 QWebSocketPrivate::maxIncomingMessageSize()
{
return QWebSocketDataProcessor::maxMessageSize();
}
/*!
\internal
*/
quint64 QWebSocketPrivate::maxIncomingFrameSize()
{
return QWebSocketDataProcessor::maxFrameSize();
}
/*!
\internal
*/
void QWebSocketPrivate::setOutgoingFrameSize(quint64 outgoingFrameSize)
{
if (outgoingFrameSize <= maxOutgoingFrameSize())
m_outgoingFrameSize = outgoingFrameSize;
}
/*!
\internal
*/
quint64 QWebSocketPrivate::outgoingFrameSize() const
{
return m_outgoingFrameSize;
}
/*!
\internal
*/
quint64 QWebSocketPrivate::maxOutgoingFrameSize()
{
return MAX_OUTGOING_FRAME_SIZE_IN_BYTES;
}
/*!
\internal
*/
void QWebSocketPrivate::setErrorString(const QString &errorString)
{
if (m_errorString != errorString)
m_errorString = errorString;
}
/*!
\internal
*/
QHostAddress QWebSocketPrivate::localAddress() const
{
QHostAddress address;
if (Q_LIKELY(m_pSocket))
address = m_pSocket->localAddress();
return address;
}
/*!
\internal
*/
quint16 QWebSocketPrivate::localPort() const
{
quint16 port = 0;
if (Q_LIKELY(m_pSocket))
port = m_pSocket->localPort();
return port;
}
/*!
\internal
*/
QAbstractSocket::PauseModes QWebSocketPrivate::pauseMode() const
{
return m_pauseMode;
}
/*!
\internal
*/
QHostAddress QWebSocketPrivate::peerAddress() const
{
QHostAddress address;
if (Q_LIKELY(m_pSocket))
address = m_pSocket->peerAddress();
return address;
}
/*!
\internal
*/
QString QWebSocketPrivate::peerName() const
{
QString name;
if (Q_LIKELY(m_pSocket))
name = m_pSocket->peerName();
return name;
}
/*!
\internal
*/
quint16 QWebSocketPrivate::peerPort() const
{
quint16 port = 0;
if (Q_LIKELY(m_pSocket))
port = m_pSocket->peerPort();
return port;
}
#ifndef QT_NO_NETWORKPROXY
/*!
\internal
*/
QNetworkProxy QWebSocketPrivate::proxy() const
{
return m_configuration.m_proxy;
}
/*!
\internal
*/
void QWebSocketPrivate::setProxy(const QNetworkProxy &networkProxy)
{
if (m_configuration.m_proxy != networkProxy)
m_configuration.m_proxy = networkProxy;
}
#endif //QT_NO_NETWORKPROXY
/*!
\internal
*/
void QWebSocketPrivate::setMaskGenerator(const QMaskGenerator *maskGenerator)
{
if (!maskGenerator)
m_pMaskGenerator = &m_defaultMaskGenerator;
else if (maskGenerator != m_pMaskGenerator)
m_pMaskGenerator = const_cast<QMaskGenerator *>(maskGenerator);
}
/*!
\internal
*/
const QMaskGenerator *QWebSocketPrivate::maskGenerator() const
{
Q_ASSERT(m_pMaskGenerator);
return m_pMaskGenerator;
}
/*!
\internal
*/
qint64 QWebSocketPrivate::readBufferSize() const
{
return m_readBufferSize;
}
/*!
\internal
*/
void QWebSocketPrivate::resume()
{
if (Q_LIKELY(m_pSocket))
m_pSocket->resume();
}
/*!
\internal
*/
void QWebSocketPrivate::setPauseMode(QAbstractSocket::PauseModes pauseMode)
{
m_pauseMode = pauseMode;
if (Q_LIKELY(m_pSocket))
m_pSocket->setPauseMode(m_pauseMode);
}
/*!
\internal
*/
void QWebSocketPrivate::setReadBufferSize(qint64 size)
{
m_readBufferSize = size;
if (Q_LIKELY(m_pSocket))
m_pSocket->setReadBufferSize(m_readBufferSize);
}
void QWebSocketPrivate::emitErrorOccurred(QAbstractSocket::SocketError error)
{
Q_Q(QWebSocket);
Q_EMIT q->errorOccurred(error);
#if QT_DEPRECATED_SINCE(6, 5)
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
Q_EMIT q->error(error);
QT_WARNING_POP
#endif
}
#ifndef Q_OS_WASM
/*!
\internal
*/
bool QWebSocketPrivate::isValid() const
{
return (m_pSocket && m_pSocket->isValid() &&
(m_socketState == QAbstractSocket::ConnectedState));
}
#endif
QT_END_NAMESPACE