qwebsocket_wasm_p.cpp

// Copyright (C) 2018 The Qt Company Ltd.

// 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_p.h"

#if QT_CONFIG(thread)

#include <QtCore/qthread.h>

#include <emscripten/threading.h>

#endif

#include <emscripten.h>

#include <emscripten/websocket.h>

#include <emscripten/val.h>

#include <QHostAddress>

static EM_BOOL q_onWebSocketErrorCallback(int eventType,

                                          const EmscriptenWebSocketErrorEvent *e,

                                          void *userData)

    Q_UNUSED(eventType)

    Q_UNUSED(e)

    QWebSocketPrivate *wsp = reinterpret_cast<QWebSocketPrivate *>(userData);

    Q_ASSERT (wsp);

    emit wsp->q_func()->errorOccurred(wsp->error());

    return EM_FALSE;

static EM_BOOL q_onWebSocketCloseCallback(int eventType,

                                          const EmscriptenWebSocketCloseEvent *emCloseEvent,

                                          void *userData)

    Q_UNUSED(eventType)

    QWebSocketPrivate *wsp = reinterpret_cast<QWebSocketPrivate *>(userData);

    Q_ASSERT (wsp);

    wsp->setSocketClosed(emCloseEvent);

    return EM_FALSE;

static EM_BOOL q_onWebSocketOpenCallback(int eventType,

                                         const EmscriptenWebSocketOpenEvent *e, void *userData)

    Q_UNUSED(eventType)

    Q_UNUSED(e)

    QWebSocketPrivate *wsp = reinterpret_cast<QWebSocketPrivate *>(userData);

    Q_ASSERT (wsp);

    wsp->setSocketState(QAbstractSocket::ConnectedState);

    emit wsp->q_func()->connected();

    return EM_FALSE;

static EM_BOOL q_onWebSocketIncomingMessageCallback(int eventType,

                                                    const EmscriptenWebSocketMessageEvent *e,

                                                    void *userData)

    Q_UNUSED(eventType)

    QWebSocketPrivate *wsp = reinterpret_cast<QWebSocketPrivate *>(userData);

    Q_ASSERT(wsp);

    if (!e->isText) {

        QByteArray buffer(reinterpret_cast<const char *>(e->data), e->numBytes);

        if (!buffer.isEmpty())

            emit wsp->q_func()->binaryMessageReceived(buffer);

    } else {

        QString buffer = QString::fromUtf8(reinterpret_cast<const char *>(e->data), e->numBytes - 1);

        emit wsp->q_func()->textMessageReceived(buffer);

    return 0;

qint64 QWebSocketPrivate::sendTextMessage(const QString &message)

    int result = 0;

    emscripten_websocket_get_ready_state(m_socketContext, &m_readyState);

    if (m_readyState == 1) {

        QByteArray messageArray = message.toUtf8();

        result = emscripten_websocket_send_utf8_text(m_socketContext, messageArray);

        if (result < 0)

            emitErrorOccurred(QAbstractSocket::UnknownSocketError);

        else

            return messageArray.length();

    } else

        qWarning() << "Could not send message. Websocket is not open";

    return result;

qint64 QWebSocketPrivate::sendBinaryMessage(const QByteArray &data)

    int result = 0;

    emscripten_websocket_get_ready_state(m_socketContext, &m_readyState);

    if (m_readyState == 1) {

        result = emscripten_websocket_send_binary(

                m_socketContext, const_cast<void *>(reinterpret_cast<const void *>(data.constData())),

                data.size());

        if (result < 0)

            emitErrorOccurred(QAbstractSocket::UnknownSocketError);

        else

            return data.size();

    } else

        qWarning() << "Could not send message. Websocket is not open";

    return result;

void QWebSocketPrivate::close(QWebSocketProtocol::CloseCode closeCode, QString reason)

    Q_Q(QWebSocket);

    m_closeCode = closeCode;

    m_closeReason = reason;

    Q_EMIT q->aboutToClose();

    setSocketState(QAbstractSocket::ClosingState);

    emscripten_websocket_get_ready_state(m_socketContext, &m_readyState);

    if (m_readyState == 1 || m_readyState == 0) {

        emscripten_websocket_close(m_socketContext, (int)closeCode, reason.toUtf8());

    setSocketState(QAbstractSocket::UnconnectedState);

    emit q->disconnected();

    emscripten_websocket_get_ready_state(m_socketContext, &m_readyState);

void QWebSocketPrivate::open(const QNetworkRequest &request,

                             const QWebSocketHandshakeOptions &options, bool mask)

    Q_UNUSED(mask);

    emscripten_websocket_get_ready_state(m_socketContext, &m_readyState);

    if ((m_readyState == 1 || m_readyState == 3) && m_socketContext != 0) {

        emitErrorOccurred(QAbstractSocket::OperationError);

        return;

    const QUrl url = request.url();

    emscripten::val navProtocol = emscripten::val::global("self")["location"]["protocol"];

    //  An insecure WebSocket connection may not be initiated from a page loaded over HTTPS.

    // and causes emscripten to assert

    bool isSecureContext = (navProtocol.as<std::string>().find("https") == 0);

    if (!url.isValid()

            || url.toString().contains(QStringLiteral("\r\n"))) {

        setErrorString(QWebSocket::tr("Connection refused"));

        emitErrorOccurred(QAbstractSocket::ConnectionRefusedError);

        return;

    // exception for localhost/127.0.0.1/[::1]

    // localhost has special privledges

    QHostAddress hostAddress(url.host());

    bool hostAddressIsLocal = (hostAddress == QHostAddress::LocalHost

            || hostAddress == QHostAddress::LocalHostIPv6);

    if (url.host() != QStringLiteral("localhost") && !hostAddressIsLocal) {

        if (isSecureContext && url.scheme() == QStringLiteral("ws")) {

            const QString message =

                    QWebSocket::tr("Unsupported WebSocket scheme: %1").arg(url.scheme());

            setErrorString(message);

            emitErrorOccurred(QAbstractSocket::UnsupportedSocketOperationError);

            return;

    setRequest(request, options);

    EmscriptenWebSocketCreateAttributes attr;

    emscripten_websocket_init_create_attributes(&attr); // memset

    QByteArray thisUrl = url.toString(QUrl::FullyEncoded).toUtf8();

    attr.url = thisUrl.constData();

#if QT_CONFIG(thread)

    // see https://github.com/emscripten-core/emscripten/blob/main/system/include/emscripten/websocket.h

    // choose a default: create websocket on calling thread

    attr.createOnMainThread = false;

#endif

    // HTML WebSockets do not support arbitrary request headers, but

    // do support the WebSocket protocol header. This header is

    // required for some use cases like MQTT.

    // add user subprotocol options

    QStringList protocols = requestedSubProtocols();

    QByteArray secProto;

    if (!protocols.isEmpty()) {

        // comma-separated list of protocol strings, no spaces

        secProto = protocols.join(QStringLiteral(",")).toLatin1();

        attr.protocols = secProto.constData();

    // create and connect

    setSocketState(QAbstractSocket::ConnectingState);

    m_socketContext = emscripten_websocket_new(&attr);

    if (m_socketContext <= 0) { // m_readyState might not be changed yet

        // error

        emitErrorOccurred(QAbstractSocket::UnknownSocketError);

        return;

#if QT_CONFIG(thread)

    emscripten_websocket_set_onopen_callback_on_thread(m_socketContext, (void *)this,

                                                       q_onWebSocketOpenCallback,

                                                       (quintptr)QThread::currentThreadId());

    emscripten_websocket_set_onmessage_callback_on_thread(m_socketContext, (void *)this,

                                                          q_onWebSocketIncomingMessageCallback,

                                                          (quintptr)QThread::currentThreadId());

    emscripten_websocket_set_onerror_callback_on_thread(m_socketContext, (void *)this,

                                                        q_onWebSocketErrorCallback,

                                                        (quintptr)QThread::currentThreadId());

    emscripten_websocket_set_onclose_callback_on_thread(m_socketContext, (void *)this,

                                                        q_onWebSocketCloseCallback,

                                                        (quintptr)QThread::currentThreadId());

#else

    emscripten_websocket_set_onopen_callback(m_socketContext, (void *)this,

                                             q_onWebSocketOpenCallback);

    emscripten_websocket_set_onmessage_callback(m_socketContext, (void *)this,

                                                q_onWebSocketIncomingMessageCallback);

    emscripten_websocket_set_onerror_callback(m_socketContext, (void *)this,

                                              q_onWebSocketErrorCallback);

    emscripten_websocket_set_onclose_callback(m_socketContext, (void *)this,

                                              q_onWebSocketCloseCallback);

#endif

bool QWebSocketPrivate::isValid() const

    return (m_socketContext > 0 && m_socketState == QAbstractSocket::ConnectedState);

void QWebSocketPrivate::setSocketClosed(const EmscriptenWebSocketCloseEvent *emCloseEvent)

    Q_Q(QWebSocket);

    m_closeCode = (QWebSocketProtocol::CloseCode)emCloseEvent->code;

    m_closeReason = QString::fromUtf8(emCloseEvent->reason);

    if (m_closeReason.isEmpty()) {

        m_closeReason = closeCodeToString(m_closeCode);

    if (m_socketState == QAbstractSocket::ConnectedState) {

        Q_EMIT q->aboutToClose();

        setSocketState(QAbstractSocket::ClosingState);

    if (!emCloseEvent->wasClean) {

        m_errorString = QStringLiteral("The remote host closed the connection");

        emit q->errorOccurred(error());

    emscripten_websocket_get_ready_state(m_socketContext, &m_readyState);

    if (m_readyState == 3) { // closed

        setSocketState(QAbstractSocket::UnconnectedState);

        emit q->disconnected();

        emscripten_websocket_delete(emCloseEvent->socket);

        m_socketContext = 0;

QString QWebSocketPrivate::closeCodeToString(QWebSocketProtocol::CloseCode code)

    switch (code) {

        case QWebSocketProtocol::CloseCodeNormal: return QStringLiteral("Normal closure");

        case QWebSocketProtocol::CloseCodeGoingAway: return QStringLiteral("Going away");

        case QWebSocketProtocol::CloseCodeProtocolError: return QStringLiteral("Protocol error");

        case QWebSocketProtocol::CloseCodeDatatypeNotSupported: return QStringLiteral("Unsupported data");

        case QWebSocketProtocol::CloseCodeReserved1004: return QStringLiteral("Reserved");

        case QWebSocketProtocol::CloseCodeMissingStatusCode: return QStringLiteral("No status received");

        case QWebSocketProtocol::CloseCodeAbnormalDisconnection: return QStringLiteral("Abnormal closure");

        case QWebSocketProtocol::CloseCodeWrongDatatype: return QStringLiteral("Invalid frame payload data");

        case QWebSocketProtocol::CloseCodePolicyViolated: return QStringLiteral("Policy violation");

        case QWebSocketProtocol::CloseCodeTooMuchData: return QStringLiteral("Message too big");

        case QWebSocketProtocol::CloseCodeMissingExtension: return QStringLiteral("Mandatory extension missing");

        case QWebSocketProtocol::CloseCodeBadOperation: return QStringLiteral("Internal server error");

        case QWebSocketProtocol::CloseCodeTlsHandshakeFailed: return QStringLiteral("TLS handshake failed");

};

    return QStringLiteral("");

Revision control

Copy as Markdown