ssl: Use QSslSocket directly to avoid redundant qobject_casts

[quassel.git] / src / client / clientauthhandler.cpp

diff --git a/src/client/clientauthhandler.cpp b/src/client/clientauthhandler.cpp
index a5bf291..469299f 100644 (file)
--- a/src/client/clientauthhandler.cpp
+++ b/src/client/clientauthhandler.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-2018 by the Quassel Project                        *
+ *   Copyright (C) 2005-2020 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -21,21 +21,13 @@
 #include "clientauthhandler.h"
 
 #include <QtEndian>
-
-#ifdef HAVE_SSL
-#    include <QSslSocket>
-#else
-#    include <QTcpSocket>
-#endif
+#include <QSslSocket>
 
 #include "client.h"
 #include "clientsettings.h"
-#include "logmessage.h"
 #include "peerfactory.h"
 #include "util.h"
 
-using namespace Protocol;
-
 ClientAuthHandler::ClientAuthHandler(CoreAccount account, QObject* parent)
     : AuthHandler(parent)
     , _peer(nullptr)
@@ -54,24 +46,9 @@ void ClientAuthHandler::connectToCore()
 {
     CoreAccountSettings s;
 
-#ifdef HAVE_SSL
     auto* socket = new QSslSocket(this);
     // make sure the warning is shown if we happen to connect without SSL support later
     s.setAccountValue("ShowNoClientSslWarning", true);
-#else
-    if (_account.useSsl()) {
-        if (s.accountValue("ShowNoClientSslWarning", true).toBool()) {
-            bool accepted = false;
-            emit handleNoSslInClient(&accepted);
-            if (!accepted) {
-                emit errorMessage(tr("Unencrypted connection canceled"));
-                return;
-            }
-            s.setAccountValue("ShowNoClientSslWarning", false);
-        }
-    }
-    QTcpSocket* socket = new QTcpSocket(this);
-#endif
 
 #ifndef QT_NO_NETWORKPROXY
     QNetworkProxy proxy;
@@ -182,10 +159,8 @@ void ClientAuthHandler::onSocketConnected()
         stream.setVersion(QDataStream::Qt_4_2);
 
         quint32 magic = Protocol::magic;
-#ifdef HAVE_SSL
         if (_account.useSsl())
             magic |= Protocol::Encryption;
-#endif
         magic |= Protocol::Compression;
 
         stream << magic;
@@ -291,20 +266,18 @@ void ClientAuthHandler::startRegistration()
 
     // useSsl will be ignored by non-legacy peers
     bool useSsl = false;
-#ifdef HAVE_SSL
     useSsl = _account.useSsl();
-#endif
 
-    _peer->dispatch(RegisterClient(Quassel::Features{}, Quassel::buildInfo().fancyVersionString, Quassel::buildInfo().commitDate, useSsl));
+    _peer->dispatch(Protocol::RegisterClient(Quassel::Features{}, Quassel::buildInfo().fancyVersionString, Quassel::buildInfo().commitDate, useSsl));
 }
 
-void ClientAuthHandler::handle(const ClientDenied& msg)
+void ClientAuthHandler::handle(const Protocol::ClientDenied& msg)
 {
     emit errorPopup(msg.errorString);
     requestDisconnect(tr("The core refused connection from this client"));
 }
 
-void ClientAuthHandler::handle(const ClientRegistered& msg)
+void ClientAuthHandler::handle(const Protocol::ClientRegistered& msg)
 {
     _coreConfigured = msg.coreConfigured;
     _backendInfo = msg.backendInfo;
@@ -324,10 +297,10 @@ void ClientAuthHandler::onConnectionReady()
     const auto& coreFeatures = _peer->features();
     auto unsupported = coreFeatures.toStringList(false);
     if (!unsupported.isEmpty()) {
-        quInfo() << qPrintable(tr("Core does not support the following features: %1").arg(unsupported.join(", ")));
+        qInfo() << qPrintable(tr("Core does not support the following features: %1").arg(unsupported.join(", ")));
     }
     if (!coreFeatures.unknownFeatures().isEmpty()) {
-        quInfo() << qPrintable(tr("Core supports unknown features: %1").arg(coreFeatures.unknownFeatures().join(", ")));
+        qInfo() << qPrintable(tr("Core supports unknown features: %1").arg(coreFeatures.unknownFeatures().join(", ")));
     }
 
     emit connectionReady();
@@ -341,17 +314,17 @@ void ClientAuthHandler::onConnectionReady()
         login();
 }
 
-void ClientAuthHandler::setupCore(const SetupData& setupData)
+void ClientAuthHandler::setupCore(const Protocol::SetupData& setupData)
 {
     _peer->dispatch(setupData);
 }
 
-void ClientAuthHandler::handle(const SetupFailed& msg)
+void ClientAuthHandler::handle(const Protocol::SetupFailed& msg)
 {
     emit coreSetupFailed(msg.errorString);
 }
 
-void ClientAuthHandler::handle(const SetupDone& msg)
+void ClientAuthHandler::handle(const Protocol::SetupDone& msg)
 {
     Q_UNUSED(msg)
 
@@ -378,22 +351,22 @@ void ClientAuthHandler::login(const QString& previousError)
         }
     }
 
-    _peer->dispatch(Login(_account.user(), _account.password()));
+    _peer->dispatch(Protocol::Login(_account.user(), _account.password()));
 }
 
-void ClientAuthHandler::handle(const LoginFailed& msg)
+void ClientAuthHandler::handle(const Protocol::LoginFailed& msg)
 {
     login(msg.errorString);
 }
 
-void ClientAuthHandler::handle(const LoginSuccess& msg)
+void ClientAuthHandler::handle(const Protocol::LoginSuccess& msg)
 {
     Q_UNUSED(msg)
 
     emit loginSuccessful(_account);
 }
 
-void ClientAuthHandler::handle(const SessionState& msg)
+void ClientAuthHandler::handle(const Protocol::SessionState& msg)
 {
     disconnect(socket(), nullptr, this, nullptr);  // this is the last message we shall ever get
 
@@ -406,21 +379,16 @@ void ClientAuthHandler::handle(const SessionState& msg)
 
 void ClientAuthHandler::checkAndEnableSsl(bool coreSupportsSsl)
 {
-#ifndef HAVE_SSL
-    Q_UNUSED(coreSupportsSsl);
-#else
     CoreAccountSettings s;
     if (coreSupportsSsl && _account.useSsl()) {
         // Make sure the warning is shown next time we don't have SSL in the core
         s.setAccountValue("ShowNoCoreSslWarning", true);
 
-        auto* sslSocket = qobject_cast<QSslSocket*>(socket());
-        Q_ASSERT(sslSocket);
-        connect(sslSocket, &QSslSocket::encrypted, this, &ClientAuthHandler::onSslSocketEncrypted);
-        connect(sslSocket, selectOverload<const QList<QSslError>&>(&QSslSocket::sslErrors), this, &ClientAuthHandler::onSslErrors);
+        connect(socket(), &QSslSocket::encrypted, this, &ClientAuthHandler::onSslSocketEncrypted);
+        connect(socket(), selectOverload<const QList<QSslError>&>(&QSslSocket::sslErrors), this, &ClientAuthHandler::onSslErrors);
         qDebug() << "Starting encryption...";
-        sslSocket->flush();
-        sslSocket->startClientEncryption();
+        socket()->flush();
+        socket()->startClientEncryption();
     }
     else {
         if (s.accountValue("ShowNoCoreSslWarning", true).toBool()) {
@@ -439,10 +407,8 @@ void ClientAuthHandler::checkAndEnableSsl(bool coreSupportsSsl)
         else
             startRegistration();
     }
-#endif
 }
 
-#ifdef HAVE_SSL
 
 void ClientAuthHandler::onSslSocketEncrypted()
 {
@@ -467,9 +433,6 @@ void ClientAuthHandler::onSslSocketEncrypted()
 
 void ClientAuthHandler::onSslErrors()
 {
-    auto* socket = qobject_cast<QSslSocket*>(sender());
-    Q_ASSERT(socket);
-
     CoreAccountSettings s;
     QByteArray knownDigest = s.accountValue("SslCert").toByteArray();
     ClientAuthHandler::DigestVersion knownDigestVersion = static_cast<ClientAuthHandler::DigestVersion>(
@@ -478,11 +441,11 @@ void ClientAuthHandler::onSslErrors()
     QByteArray calculatedDigest;
     switch (knownDigestVersion) {
     case ClientAuthHandler::DigestVersion::Md5:
-        calculatedDigest = socket->peerCertificate().digest(QCryptographicHash::Md5);
+        calculatedDigest = socket()->peerCertificate().digest(QCryptographicHash::Md5);
         break;
 
     case ClientAuthHandler::DigestVersion::Sha2_512:
-        calculatedDigest = socket->peerCertificate().digest(QCryptographicHash::Sha512);
+        calculatedDigest = socket()->peerCertificate().digest(QCryptographicHash::Sha512);
         break;
 
     default:
@@ -492,7 +455,7 @@ void ClientAuthHandler::onSslErrors()
     if (knownDigest != calculatedDigest) {
         bool accepted = false;
         bool permanently = false;
-        emit handleSslErrors(socket, &accepted, &permanently);
+        emit handleSslErrors(socket(), &accepted, &permanently);
 
         if (!accepted) {
             requestDisconnect(tr("Unencrypted connection canceled"));
@@ -500,7 +463,7 @@ void ClientAuthHandler::onSslErrors()
         }
 
         if (permanently) {
-            s.setAccountValue("SslCert", socket->peerCertificate().digest(QCryptographicHash::Sha512));
+            s.setAccountValue("SslCert", socket()->peerCertificate().digest(QCryptographicHash::Sha512));
             s.setAccountValue("SslCertDigestVersion", ClientAuthHandler::DigestVersion::Latest);
         }
         else {
@@ -509,11 +472,9 @@ void ClientAuthHandler::onSslErrors()
         }
     }
     else if (knownDigestVersion != ClientAuthHandler::DigestVersion::Latest) {
-        s.setAccountValue("SslCert", socket->peerCertificate().digest(QCryptographicHash::Sha512));
+        s.setAccountValue("SslCert", socket()->peerCertificate().digest(QCryptographicHash::Sha512));
         s.setAccountValue("SslCertDigestVersion", ClientAuthHandler::DigestVersion::Latest);
     }
 
-    socket->ignoreSslErrors();
+    socket()->ignoreSslErrors();
 }
-
-#endif /* HAVE_SSL */