QSslSocket - introduce the API providing information about backends

This API gives the names of available backends and provides a basic
information about features/protocols supported by those backends.
Also, it has the 'loadBackend' functions which allow to select
a particular backend (which are becoming plugins).

At the moment, the implementation is still 'hardcoded', the
follow-up patch will allow to select different backends in runtime.

Task-number: QTBUG-65922
Change-Id: I05877de9c02857594e76b24d52e7578bdb01df69
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>

1 files changed, 87 insertions, 0 deletions

diff --git a/src/network/ssl/qsslsocket_mac.cpp b/src/network/ssl/qsslsocket_mac.cpp
index 9eb9609315..9f1d8d1e54 100644
--- a/src/network/ssl/qsslsocket_mac.cpp
+++ b/src/network/ssl/qsslsocket_mac.cpp
@@ -1,5 +1,6 @@
 /****************************************************************************
 **
+** Copyright (C) 2021 The Qt Company Ltd.
 ** Copyright (C) 2014 Jeremy Lainé <jeremy.laine@m4x.org>
 ** Contact: https://www.qt.io/licensing/
 **
@@ -1551,4 +1552,90 @@ bool QSslSocketBackendPrivate::startHandshake()
     }
 }
 
+QList<QString> QSslSocketPrivate::availableBackends()
+{
+    return {QStringLiteral("securetransport")};
+}
+
+QString QSslSocketPrivate::activeBackend()
+{
+    return availableBackends().first();
+}
+
+bool QSslSocketPrivate::loadBackend(const QString &backendName)
+{
+    if (backendName.size() && !availableBackends().contains(backendName)) {
+        qCWarning(lcSsl) << "A TLS backend with name" << backendName << "is not available";
+        return false;
+    }
+
+    static bool loaded = false;
+    static QBasicMutex mutex;
+    const QMutexLocker locker(&mutex);
+    if (loaded) {
+        qCWarning(lcSsl) << "You have already loaded the backend named:" << activeBackend();
+        if (backendName.size())
+            qCWarning(lcSsl) << "Cannot load:" << backendName;
+        else
+            qCWarning(lcSsl) << "Cannot load the default backend (securetransport)";
+        return true;
+    }
+    // This code to be placed in qsslsocket.cpp and there
+    // the actual plugin to be loaded (so the result can be
+    // false if we, for example, failed to resolve OpenSSL
+    // symbols).
+    return loaded = true;
+}
+
+QList<QSsl::SslProtocol> QSslSocketPrivate::supportedProtocols(const QString &backendName)
+{
+    QList<QSsl::SslProtocol> protocols;
+    if (backendName.size() && backendName != activeBackend()) {
+        qCWarning(lcSsl) << "Unexpected backend name" << backendName
+                         << "no information about protocols supported can be found";
+        return protocols;
+    }
+
+    protocols << QSsl::AnyProtocol;
+    protocols << QSsl::SecureProtocols;
+    protocols << QSsl::TlsV1_0;
+    protocols << QSsl::TlsV1_0OrLater;
+    protocols << QSsl::TlsV1_1;
+    protocols << QSsl::TlsV1_1OrLater;
+    protocols << QSsl::TlsV1_2;
+    protocols << QSsl::TlsV1_2OrLater;
+
+    return protocols;
+}
+
+QList<QSsl::ImplementedClass> QSslSocketPrivate::implementedClasses(const QString &backendName)
+{
+    QList<QSsl::ImplementedClass> classes;
+    if (backendName.size() && backendName != activeBackend()) {
+        qCWarning(lcSsl) << "Unexpected backend name" << backendName
+                         << "no information about classes implemented can be found";
+        return classes;
+    }
+
+    classes << QSsl::ImplementedClass::Key;
+    classes << QSsl::ImplementedClass::Certificate;
+    classes << QSsl::ImplementedClass::Socket;
+
+    return classes;
+}
+
+QList<QSsl::SupportedFeature> QSslSocketPrivate::supportedFeatures(const QString &backendName)
+{
+    QList<QSsl::SupportedFeature> features;
+    if (backendName.size() && backendName != activeBackend()) {
+        qCWarning(lcSsl) << "Unexpected backend name" << backendName
+                         << "no information about classes implemented can be found";
+        return features;
+    }
+
+    features << QSsl::SupportedFeature::ClientSideAlpn;
+
+    return features;
+}
+
 QT_END_NAMESPACE