qsslserver.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// 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
 
#include "qsslserver.h"
#include "qsslserver_p.h"
 
#include <QtNetwork/QSslSocket>
#include <QtNetwork/QSslCipher>
 
QT_BEGIN_NAMESPACE
 
QSslServerPrivate::QSslServerPrivate() :
    sslConfiguration(QSslConfiguration::defaultConfiguration())
{
}
 
QSslServer::QSslServer(QObject *parent) :
    QTcpServer(QAbstractSocket::TcpSocket, *new QSslServerPrivate, parent)
{
}
 
QSslServer::~QSslServer()
{
}
 
void QSslServer::setSslConfiguration(const QSslConfiguration &sslConfiguration)
{
    Q_D(QSslServer);
    d->sslConfiguration = sslConfiguration;
}
 
QSslConfiguration QSslServer::sslConfiguration() const
{
    const Q_D(QSslServer);
    return d->sslConfiguration;
}
 
void QSslServer::setHandshakeTimeout(int timeout)
{
    Q_D(QSslServer);
    d->handshakeTimeout = timeout;
}
 
int QSslServer::handshakeTimeout() const
{
    const Q_D(QSslServer);
    return d->handshakeTimeout;
}
 
void QSslServer::incomingConnection(qintptr socket)
{
    QSslSocket *pSslSocket = new QSslSocket(this);
 
    pSslSocket->setSslConfiguration(sslConfiguration());
 
    if (Q_LIKELY(pSslSocket->setSocketDescriptor(socket))) {
        connect(pSslSocket, &QSslSocket::peerVerifyError, this,
                [this, pSslSocket](const QSslError &error) {
                    Q_EMIT peerVerifyError(pSslSocket, error);
                });
        connect(pSslSocket, &QSslSocket::sslErrors, this,
                [this, pSslSocket](const QList<QSslError> &errors) {
                    Q_EMIT sslErrors(pSslSocket, errors);
                });
        connect(pSslSocket, &QAbstractSocket::errorOccurred, this,
                [this, pSslSocket](QAbstractSocket::SocketError error) {
                    Q_EMIT errorOccurred(pSslSocket, error);
                    if (!pSslSocket->isEncrypted())
                        pSslSocket->deleteLater();
                });
        connect(pSslSocket, &QSslSocket::encrypted, this, [this, pSslSocket]() {
            Q_D(QSslServer);
            d->removeSocketData(quintptr(pSslSocket));
            pSslSocket->disconnect(this);
            addPendingConnection(pSslSocket);
        });
        connect(pSslSocket, &QSslSocket::preSharedKeyAuthenticationRequired, this,
                [this, pSslSocket](QSslPreSharedKeyAuthenticator *authenticator) {
                    Q_EMIT preSharedKeyAuthenticationRequired(pSslSocket, authenticator);
                });
        connect(pSslSocket, &QSslSocket::alertSent, this,
                [this, pSslSocket](QSsl::AlertLevel level, QSsl::AlertType type,
                                   const QString &description) {
                    Q_EMIT alertSent(pSslSocket, level, type, description);
                });
        connect(pSslSocket, &QSslSocket::alertReceived, this,
                [this, pSslSocket](QSsl::AlertLevel level, QSsl::AlertType type,
                                   const QString &description) {
                    Q_EMIT alertReceived(pSslSocket, level, type, description);
                });
        connect(pSslSocket, &QSslSocket::handshakeInterruptedOnError, this,
                [this, pSslSocket](const QSslError &error) {
                    Q_EMIT handshakeInterruptedOnError(pSslSocket, error);
                });
 
        d_func()->initializeHandshakeProcess(pSslSocket);
    }
}
 
void QSslServerPrivate::initializeHandshakeProcess(QSslSocket *socket)
{
    Q_Q(QSslServer);
    QMetaObject::Connection readyRead = QObject::connect(
            socket, &QSslSocket::readyRead, q, [this]() { checkClientHelloAndContinue(); });
 
    QMetaObject::Connection destroyed =
            QObject::connect(socket, &QSslSocket::destroyed, q, [this](QObject *obj) {
                // This cast is not safe to use since the socket is inside the
                // QObject dtor, but we only use the pointer value!
                removeSocketData(quintptr(obj));
            });
    auto it = socketData.emplace(quintptr(socket), readyRead, destroyed, std::make_shared<QTimer>());
    it->timeoutTimer->setSingleShot(true);
    it->timeoutTimer->callOnTimeout(q, [this, socket]() { handleHandshakeTimedOut(socket); });
    it->timeoutTimer->setInterval(handshakeTimeout);
    it->timeoutTimer->start();
}
 
// This function may be called while in the socket's QObject dtor, __never__ use
// the socket for anything other than a lookup!
void QSslServerPrivate::removeSocketData(quintptr socket)
{
    auto it = socketData.find(socket);
    if (it != socketData.end()) {
        it->disconnectSignals();
        socketData.erase(it);
    }
}
 
int QSslServerPrivate::totalPendingConnections() const
{
    // max pending connections is int, so this cannot exceed that
    return QTcpServerPrivate::totalPendingConnections() + int(socketData.size());
}
 
void QSslServerPrivate::checkClientHelloAndContinue()
{
    Q_Q(QSslServer);
    QSslSocket *socket = qobject_cast<QSslSocket *>(q->sender());
    if (Q_UNLIKELY(!socket) || socket->bytesAvailable() <= 0)
        return;
 
    char byte = '\0';
    if (socket->peek(&byte, 1) != 1) {
        socket->deleteLater();
        return;
    }
 
    auto it = socketData.find(quintptr(socket));
    const bool foundData = it != socketData.end();
    if (foundData && it->readyReadConnection)
        QObject::disconnect(std::exchange(it->readyReadConnection, {}));
 
    constexpr char CLIENT_HELLO = 0x16;
    if (byte != CLIENT_HELLO) {
        socket->disconnectFromHost();
        socket->deleteLater();
        return;
    }
 
    // Be nice and restart the timeout timer since some progress was made
    if (foundData)
        it->timeoutTimer->start();
 
    socket->startServerEncryption();
    Q_EMIT q->startedEncryptionHandshake(socket);
}
 
void QSslServerPrivate::handleHandshakeTimedOut(QSslSocket *socket)
{
    Q_Q(QSslServer);
    removeSocketData(quintptr(socket));
    socket->disconnectFromHost();
    Q_EMIT q->errorOccurred(socket, QAbstractSocket::SocketTimeoutError);
    socket->deleteLater();
    if (!socketEngine->isReadNotificationEnabled() && totalPendingConnections() < maxConnections)
        q->resumeAccepting();
}
 
QT_END_NAMESPACE
 
#include "moc_qsslserver.cpp"