qnetworkaccessmanager.cpp

Go to the documentation of this file.

// Copyright (C) 2020 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
 
#include <QtNetwork/private/qtnetworkglobal_p.h>
 
#include "qnetworkaccessmanager.h"
#include "qnetworkaccessmanager_p.h"
#include "qnetworkrequest.h"
#include "qnetworkreply.h"
#include "qnetworkreply_p.h"
#include "qnetworkcookie.h"
#include "qnetworkcookiejar.h"
#include "qabstractnetworkcache.h"
#include "qhstspolicy.h"
#include "qhsts_p.h"
 
#if QT_CONFIG(settings)
#include "qhstsstore_p.h"
#endif // QT_CONFIG(settings)
 
#include "qnetworkaccessfilebackend_p.h"
#include "qnetworkaccessdebugpipebackend_p.h"
#include "qnetworkaccesscachebackend_p.h"
#include "qnetworkreplydataimpl_p.h"
#include "qnetworkreplyfileimpl_p.h"
 
#include "qnetworkaccessbackend_p.h"
#include "qnetworkreplyimpl_p.h"
 
#include "QtCore/qbuffer.h"
#include "QtCore/qlist.h"
#include "QtCore/qurl.h"
#include "QtNetwork/private/qauthenticator_p.h"
#include "QtNetwork/qsslconfiguration.h"
 
#if QT_CONFIG(http)
#include "QtNetwork/private/http2protocol_p.h"
#include "qhttpmultipart.h"
#include "qhttpmultipart_p.h"
#include "qnetworkreplyhttpimpl_p.h"
#endif
 
#include "qthread.h"
 
#include <QHostInfo>
 
#include "QtCore/qapplicationstatic.h"
#include "QtCore/qloggingcategory.h"
#include <QtCore/private/qfactoryloader_p.h>
 
#if defined(Q_OS_MACOS)
#include <QtCore/private/qcore_mac_p.h>
 
#include <CoreServices/CoreServices.h>
#include <SystemConfiguration/SystemConfiguration.h>
#include <Security/Security.h>
#endif
#ifdef Q_OS_WASM
#include "qnetworkreplywasmimpl_p.h"
#include "qhttpmultipart.h"
#include "qhttpmultipart_p.h"
#endif
 
#include "qnetconmonitor_p.h"
 
#include <mutex>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
using namespace std::chrono_literals;
 
Q_LOGGING_CATEGORY(lcQnam, "qt.network.access.manager")
 
Q_APPLICATION_STATIC(QNetworkAccessFileBackendFactory, fileBackend)
 
#if QT_CONFIG(private_tests)
Q_GLOBAL_STATIC(QNetworkAccessDebugPipeBackendFactory, debugpipeBackend)
#endif
 
Q_APPLICATION_STATIC(QFactoryLoader, qnabfLoader, QNetworkAccessBackendFactory_iid, "/networkaccess"_L1)
 
#if defined(Q_OS_MACOS)
bool getProxyAuth(const QString& proxyHostname, const QString &scheme, QString& username, QString& password)
{
    CFStringRef protocolType = nullptr;
    if (scheme.compare("ftp"_L1, Qt::CaseInsensitive) == 0) {
        protocolType = kSecAttrProtocolFTPProxy;
    } else if (scheme.compare("http"_L1, Qt::CaseInsensitive) == 0
               || scheme.compare("preconnect-http"_L1, Qt::CaseInsensitive) == 0) {
        protocolType = kSecAttrProtocolHTTPProxy;
    } else if (scheme.compare("https"_L1,Qt::CaseInsensitive)==0
               || scheme.compare("preconnect-https"_L1, Qt::CaseInsensitive) == 0) {
        protocolType = kSecAttrProtocolHTTPSProxy;
    } else {
        qCWarning(lcQnam) << "Cannot query user name and password for a proxy, unnknown protocol:"
                          << scheme;
        return false;
    }
 
    QCFType<CFMutableDictionaryRef> query(CFDictionaryCreateMutable(kCFAllocatorDefault,
                                                                    0, nullptr, nullptr));
    Q_ASSERT(query);
 
    CFDictionaryAddValue(query, kSecClass, kSecClassInternetPassword);
    CFDictionaryAddValue(query, kSecAttrProtocol, protocolType);
 
    QCFType<CFStringRef> serverName; // Note the scope.
    if (proxyHostname.size()) {
        serverName = proxyHostname.toCFString();
        CFDictionaryAddValue(query, kSecAttrServer, serverName);
    }
 
    // This is to get the user name in the result:
    CFDictionaryAddValue(query, kSecReturnAttributes, kCFBooleanTrue);
    // This one to get the password:
    CFDictionaryAddValue(query, kSecReturnData, kCFBooleanTrue);
 
    // The default for kSecMatchLimit key is 1 (the first match only), which is fine,
    // so don't set this value explicitly.
 
    QCFType<CFTypeRef> replyData;
    if (SecItemCopyMatching(query, &replyData) != errSecSuccess) {
        qCWarning(lcQnam, "Failed to extract user name and password from the keychain.");
        return false;
    }
 
    if (!replyData || CFDictionaryGetTypeID() != CFGetTypeID(replyData)) {
        qCWarning(lcQnam, "Query returned data in unexpected format.");
        return false;
    }
 
    CFDictionaryRef accountData = replyData.as<CFDictionaryRef>();
    const void *value = CFDictionaryGetValue(accountData, kSecAttrAccount);
    if (!value || CFGetTypeID(value) != CFStringGetTypeID()) {
        qCWarning(lcQnam, "Cannot find user name or its format is unknown.");
        return false;
    }
    username = QString::fromCFString(static_cast<CFStringRef>(value));
 
    value = CFDictionaryGetValue(accountData, kSecValueData);
    if (!value || CFGetTypeID(value) != CFDataGetTypeID()) {
        qCWarning(lcQnam, "Cannot find password or its format is unknown.");
        return false;
    }
    const CFDataRef passData = static_cast<const CFDataRef>(value);
    password = QString::fromLocal8Bit(reinterpret_cast<const char *>(CFDataGetBytePtr(passData)),
                                      qsizetype(CFDataGetLength(passData)));
    return true;
}
#endif // Q_OS_MACOS
 
 
 
static void ensureInitialized()
{
#if QT_CONFIG(private_tests)
    (void) debugpipeBackend();
#endif
 
    // leave this one last since it will query the special QAbstractFileEngines
    (void) fileBackend();
}
 
QNetworkAccessManager::QNetworkAccessManager(QObject *parent)
    : QObject(*new QNetworkAccessManagerPrivate, parent)
{
    ensureInitialized();
    d_func()->ensureBackendPluginsLoaded();
 
    qRegisterMetaType<QNetworkReply::NetworkError>();
#ifndef QT_NO_NETWORKPROXY
    qRegisterMetaType<QNetworkProxy>();
#endif
#ifndef QT_NO_SSL
    qRegisterMetaType<QList<QSslError> >();
    qRegisterMetaType<QSslConfiguration>();
    qRegisterMetaType<QSslPreSharedKeyAuthenticator *>();
#endif
    qRegisterMetaType<QList<QPair<QByteArray,QByteArray> > >();
#if QT_CONFIG(http)
    qRegisterMetaType<QHttpNetworkRequest>();
#endif
    qRegisterMetaType<QNetworkReply::NetworkError>();
    qRegisterMetaType<QSharedPointer<char> >();
}
 
QNetworkAccessManager::~QNetworkAccessManager()
{
#ifndef QT_NO_NETWORKPROXY
    delete d_func()->proxyFactory;
#endif
 
    // Delete the QNetworkReply children first.
    // Else a QAbstractNetworkCache might get deleted in ~QObject
    // before a QNetworkReply that accesses the QAbstractNetworkCache
    // object in its destructor.
    qDeleteAll(findChildren<QNetworkReply *>());
    // The other children will be deleted in this ~QObject
    // FIXME instead of this "hack" make the QNetworkReplyImpl
    // properly watch the cache deletion, e.g. via a QWeakPointer.
}
 
#ifndef QT_NO_NETWORKPROXY
QNetworkProxy QNetworkAccessManager::proxy() const
{
    return d_func()->proxy;
}
 
void QNetworkAccessManager::setProxy(const QNetworkProxy &proxy)
{
    Q_D(QNetworkAccessManager);
    delete d->proxyFactory;
    d->proxy = proxy;
    d->proxyFactory = nullptr;
}
 
QNetworkProxyFactory *QNetworkAccessManager::proxyFactory() const
{
    return d_func()->proxyFactory;
}
 
void QNetworkAccessManager::setProxyFactory(QNetworkProxyFactory *factory)
{
    Q_D(QNetworkAccessManager);
    delete d->proxyFactory;
    d->proxyFactory = factory;
    d->proxy = QNetworkProxy();
}
#endif
 
QAbstractNetworkCache *QNetworkAccessManager::cache() const
{
    Q_D(const QNetworkAccessManager);
    return d->networkCache;
}
 
void QNetworkAccessManager::setCache(QAbstractNetworkCache *cache)
{
    Q_D(QNetworkAccessManager);
    if (d->networkCache != cache) {
        delete d->networkCache;
        d->networkCache = cache;
        if (d->networkCache)
            d->networkCache->setParent(this);
    }
}
 
QNetworkCookieJar *QNetworkAccessManager::cookieJar() const
{
    Q_D(const QNetworkAccessManager);
    if (!d->cookieJar)
        d->createCookieJar();
    return d->cookieJar;
}
 
void QNetworkAccessManager::setCookieJar(QNetworkCookieJar *cookieJar)
{
    Q_D(QNetworkAccessManager);
    d->cookieJarCreated = true;
    if (d->cookieJar != cookieJar) {
        if (d->cookieJar && d->cookieJar->parent() == this)
            delete d->cookieJar;
        d->cookieJar = cookieJar;
        if (cookieJar && thread() == cookieJar->thread())
            d->cookieJar->setParent(this);
    }
}
 
void QNetworkAccessManager::setStrictTransportSecurityEnabled(bool enabled)
{
    Q_D(QNetworkAccessManager);
    d->stsEnabled = enabled;
}
 
bool QNetworkAccessManager::isStrictTransportSecurityEnabled() const
{
    Q_D(const QNetworkAccessManager);
    return d->stsEnabled;
}
 
void QNetworkAccessManager::enableStrictTransportSecurityStore(bool enabled, const QString &storeDir)
{
#if QT_CONFIG(settings)
    Q_D(QNetworkAccessManager);
    d->stsStore.reset(enabled ? new QHstsStore(storeDir) : nullptr);
    d->stsCache.setStore(d->stsStore.data());
#else
    Q_UNUSED(enabled);
    Q_UNUSED(storeDir);
    qWarning("HSTS permanent store requires the feature 'settings' enabled");
#endif // QT_CONFIG(settings)
}
 
bool QNetworkAccessManager::isStrictTransportSecurityStoreEnabled() const
{
#if QT_CONFIG(settings)
    Q_D(const QNetworkAccessManager);
    return bool(d->stsStore.data());
#else
    return false;
#endif // QT_CONFIG(settings)
}
 
void QNetworkAccessManager::addStrictTransportSecurityHosts(const QList<QHstsPolicy> &knownHosts)
{
    Q_D(QNetworkAccessManager);
    d->stsCache.updateFromPolicies(knownHosts);
}
 
QList<QHstsPolicy> QNetworkAccessManager::strictTransportSecurityHosts() const
{
    Q_D(const QNetworkAccessManager);
    return d->stsCache.policies();
}
 
QNetworkReply *QNetworkAccessManager::head(const QNetworkRequest &request)
{
    return d_func()->postProcess(createRequest(QNetworkAccessManager::HeadOperation, request));
}
 
QNetworkReply *QNetworkAccessManager::get(const QNetworkRequest &request)
{
    return d_func()->postProcess(createRequest(QNetworkAccessManager::GetOperation, request));
}
 
QNetworkReply *QNetworkAccessManager::get(const QNetworkRequest &request, QIODevice *data)
{
    QNetworkRequest newRequest(request);
    return d_func()->postProcess(
            createRequest(QNetworkAccessManager::GetOperation, newRequest, data));
}
 
QNetworkReply *QNetworkAccessManager::get(const QNetworkRequest &request, const QByteArray &data)
{
    QBuffer *buffer = new QBuffer;
    buffer->setData(data);
    buffer->open(QIODevice::ReadOnly);
 
    QNetworkReply *reply = get(request, buffer);
    buffer->setParent(reply);
    return reply;
}
 
QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, QIODevice *data)
{
    return d_func()->postProcess(createRequest(QNetworkAccessManager::PostOperation, request, data));
}
 
QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, const QByteArray &data)
{
    QBuffer *buffer = new QBuffer;
    buffer->setData(data);
    buffer->open(QIODevice::ReadOnly);
 
    QNetworkReply *reply = post(request, buffer);
    buffer->setParent(reply);
    return reply;
}
 
QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, std::nullptr_t nptr)
{
    Q_UNUSED(nptr);
    QIODevice *dev = nullptr;
 
    return d_func()->postProcess(createRequest(QNetworkAccessManager::PostOperation,
                                               request,
                                               dev));
}
 
#if QT_CONFIG(http) || defined(Q_OS_WASM)
QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, QHttpMultiPart *multiPart)
{
    QNetworkRequest newRequest = d_func()->prepareMultipart(request, multiPart);
    QIODevice *device = multiPart->d_func()->device;
    QNetworkReply *reply = post(newRequest, device);
    return reply;
}
 
QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, QHttpMultiPart *multiPart)
{
    QNetworkRequest newRequest = d_func()->prepareMultipart(request, multiPart);
    QIODevice *device = multiPart->d_func()->device;
    QNetworkReply *reply = put(newRequest, device);
    return reply;
}
#endif // QT_CONFIG(http)
 
QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, QIODevice *data)
{
    return d_func()->postProcess(createRequest(QNetworkAccessManager::PutOperation, request, data));
}
 
QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, const QByteArray &data)
{
    QBuffer *buffer = new QBuffer;
    buffer->setData(data);
    buffer->open(QIODevice::ReadOnly);
 
    QNetworkReply *reply = put(request, buffer);
    buffer->setParent(reply);
    return reply;
}
 
QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, std::nullptr_t nptr)
{
    Q_UNUSED(nptr);
    QIODevice *dev = nullptr;
 
    return d_func()->postProcess(createRequest(QNetworkAccessManager::PutOperation, request, dev));
}
 
QNetworkReply *QNetworkAccessManager::deleteResource(const QNetworkRequest &request)
{
    return d_func()->postProcess(createRequest(QNetworkAccessManager::DeleteOperation, request));
}
 
#ifndef QT_NO_SSL
void QNetworkAccessManager::connectToHostEncrypted(const QString &hostName, quint16 port,
                                                   const QSslConfiguration &sslConfiguration)
{
    connectToHostEncrypted(hostName, port, sslConfiguration, QString());
}
 
void QNetworkAccessManager::connectToHostEncrypted(const QString &hostName, quint16 port,
                                                   const QSslConfiguration &sslConfiguration,
                                                   const QString &peerName)
{
    QUrl url;
    url.setHost(hostName);
    url.setPort(port);
    url.setScheme("preconnect-https"_L1);
    QNetworkRequest request(url);
    if (sslConfiguration != QSslConfiguration::defaultConfiguration())
        request.setSslConfiguration(sslConfiguration);
 
    // There is no way to enable HTTP2 via a request after having established the connection,
    // so we need to check the ssl configuration whether HTTP2 is allowed here.
    if (!sslConfiguration.allowedNextProtocols().contains(QSslConfiguration::ALPNProtocolHTTP2))
        request.setAttribute(QNetworkRequest::Http2AllowedAttribute, false);
 
    request.setPeerVerifyName(peerName);
    get(request);
}
#endif
 
void QNetworkAccessManager::connectToHost(const QString &hostName, quint16 port)
{
    QUrl url;
    url.setHost(hostName);
    url.setPort(port);
    url.setScheme("preconnect-http"_L1);
    QNetworkRequest request(url);
    get(request);
}
 
void QNetworkAccessManager::setRedirectPolicy(QNetworkRequest::RedirectPolicy policy)
{
    Q_D(QNetworkAccessManager);
    d->redirectPolicy = policy;
}
 
QNetworkRequest::RedirectPolicy QNetworkAccessManager::redirectPolicy() const
{
    Q_D(const QNetworkAccessManager);
    return d->redirectPolicy;
}
 
QNetworkReply *QNetworkAccessManager::sendCustomRequest(const QNetworkRequest &request, const QByteArray &verb, QIODevice *data)
{
    QNetworkRequest newRequest(request);
    newRequest.setAttribute(QNetworkRequest::CustomVerbAttribute, verb);
    return d_func()->postProcess(createRequest(QNetworkAccessManager::CustomOperation, newRequest, data));
}
 
QNetworkReply *QNetworkAccessManager::sendCustomRequest(const QNetworkRequest &request, const QByteArray &verb, const QByteArray &data)
{
    QBuffer *buffer = new QBuffer;
    buffer->setData(data);
    buffer->open(QIODevice::ReadOnly);
 
    QNetworkReply *reply = sendCustomRequest(request, verb, buffer);
    buffer->setParent(reply);
    return reply;
}
 
#if QT_CONFIG(http) || defined(Q_OS_WASM)
QNetworkReply *QNetworkAccessManager::sendCustomRequest(const QNetworkRequest &request, const QByteArray &verb, QHttpMultiPart *multiPart)
{
    QNetworkRequest newRequest = d_func()->prepareMultipart(request, multiPart);
    QIODevice *device = multiPart->d_func()->device;
    QNetworkReply *reply = sendCustomRequest(newRequest, verb, device);
    return reply;
}
#endif // QT_CONFIG(http)
 
QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Operation op,
                                                    const QNetworkRequest &originalReq,
                                                    QIODevice *outgoingData)
{
    Q_D(QNetworkAccessManager);
 
    QNetworkRequest req(originalReq);
    if (redirectPolicy() != QNetworkRequest::NoLessSafeRedirectPolicy
        && req.attribute(QNetworkRequest::RedirectPolicyAttribute).isNull()) {
        req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, redirectPolicy());
    }
 
#if QT_CONFIG(http) || defined (Q_OS_WASM)
    if (req.transferTimeoutAsDuration() == 0ms)
        req.setTransferTimeout(transferTimeoutAsDuration());
#endif
 
    if (autoDeleteReplies()
        && req.attribute(QNetworkRequest::AutoDeleteReplyOnFinishAttribute).isNull()) {
        req.setAttribute(QNetworkRequest::AutoDeleteReplyOnFinishAttribute, true);
    }
 
    bool isLocalFile = req.url().isLocalFile();
    QString scheme = req.url().scheme();
 
    // Remap local+http to unix+http to make further processing easier
    if (scheme == "local+http"_L1) {
        scheme = u"unix+http"_s;
        QUrl url = req.url();
        url.setScheme(scheme);
        req.setUrl(url);
    }
 
    // fast path for GET on file:// URLs
    // The QNetworkAccessFileBackend will right now only be used for PUT
    if (op == QNetworkAccessManager::GetOperation
     || op == QNetworkAccessManager::HeadOperation) {
        if (isLocalFile
#ifdef Q_OS_ANDROID
            || scheme == "assets"_L1
#endif
            || scheme == "qrc"_L1) {
            return new QNetworkReplyFileImpl(this, req, op);
        }
 
        if (scheme == "data"_L1)
            return new QNetworkReplyDataImpl(this, req, op);
 
        // A request with QNetworkRequest::AlwaysCache does not need any bearer management
        QNetworkRequest::CacheLoadControl mode =
            static_cast<QNetworkRequest::CacheLoadControl>(
                req.attribute(QNetworkRequest::CacheLoadControlAttribute,
                              QNetworkRequest::PreferNetwork).toInt());
        if (mode == QNetworkRequest::AlwaysCache) {
            // FIXME Implement a QNetworkReplyCacheImpl instead, see QTBUG-15106
            QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
            QNetworkReplyImplPrivate *priv = reply->d_func();
            priv->manager = this;
            priv->backend = new QNetworkAccessCacheBackend();
            priv->backend->setManagerPrivate(this->d_func());
            priv->backend->setParent(reply);
            priv->backend->setReplyPrivate(priv);
            priv->setup(op, req, outgoingData);
            return reply;
        }
    }
    QNetworkRequest request = req;
    auto h = request.headers();
#ifndef Q_OS_WASM // Content-length header is not allowed to be set by user in wasm
    if (!h.contains(QHttpHeaders::WellKnownHeader::ContentLength) &&
        outgoingData && !outgoingData->isSequential()) {
        // request has no Content-Length
        // but the data that is outgoing is random-access
        h.append(QHttpHeaders::WellKnownHeader::ContentLength,
                 QByteArray::number(outgoingData->size()));
    }
#endif
    if (static_cast<QNetworkRequest::LoadControl>
        (request.attribute(QNetworkRequest::CookieLoadControlAttribute,
                           QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Automatic) {
        if (d->cookieJar) {
            QList<QNetworkCookie> cookies = d->cookieJar->cookiesForUrl(request.url());
            if (!cookies.isEmpty())
                h.replaceOrAppend(QHttpHeaders::WellKnownHeader::Cookie,
                                  QNetworkHeadersPrivate::fromCookieList(cookies));
        }
    }
    request.setHeaders(std::move(h));
#ifdef Q_OS_WASM
    Q_UNUSED(isLocalFile);
    // Support http, https, and relative urls
    if (scheme == "http"_L1 || scheme == "https"_L1 || scheme.isEmpty()) {
        QNetworkReplyWasmImpl *reply = new QNetworkReplyWasmImpl(this);
        QNetworkReplyWasmImplPrivate *priv = reply->d_func();
        priv->manager = this;
        priv->setup(op, request, outgoingData);
        return reply;
    }
#endif
 
#if QT_CONFIG(http)
    constexpr char16_t httpSchemes[][17] = {
        u"http",
        u"preconnect-http",
#ifndef QT_NO_SSL
        u"https",
        u"preconnect-https",
#endif
        u"unix+http",
    };
    // Since Qt 5 we use the new QNetworkReplyHttpImpl
    if (std::find(std::begin(httpSchemes), std::end(httpSchemes), scheme) != std::end(httpSchemes)) {
 
#ifndef QT_NO_SSL
        const bool isLocalSocket = scheme.startsWith("unix"_L1);
        if (!isLocalSocket && isStrictTransportSecurityEnabled()
            && d->stsCache.isKnownHost(request.url())) {
            QUrl stsUrl(request.url());
            // RFC6797, 8.3:
            // The UA MUST replace the URI scheme with "https" [RFC2818],
            // and if the URI contains an explicit port component of "80",
            // then the UA MUST convert the port component to be "443", or
            // if the URI contains an explicit port component that is not
            // equal to "80", the port component value MUST be preserved;
            // otherwise,
            // if the URI does not contain an explicit port component, the UA
            // MUST NOT add one.
            if (stsUrl.port() == 80)
                stsUrl.setPort(443);
            stsUrl.setScheme("https"_L1);
            request.setUrl(stsUrl);
        }
#endif
        QNetworkReplyHttpImpl *reply = new QNetworkReplyHttpImpl(this, request, op, outgoingData);
        return reply;
    }
#endif // QT_CONFIG(http)
 
    // first step: create the reply
    QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
    QNetworkReplyImplPrivate *priv = reply->d_func();
    priv->manager = this;
 
    // second step: fetch cached credentials
    // This is not done for the time being, we should use signal emissions to request
    // the credentials from cache.
 
    // third step: find a backend
    priv->backend = d->findBackend(op, request);
 
    if (priv->backend) {
        priv->backend->setParent(reply);
        priv->backend->setReplyPrivate(priv);
    }
 
#ifndef QT_NO_SSL
    reply->setSslConfiguration(request.sslConfiguration());
#endif
 
    // fourth step: setup the reply
    priv->setup(op, request, outgoingData);
 
    return reply;
}
 
QStringList QNetworkAccessManager::supportedSchemes() const
{
    QStringList schemes;
    QNetworkAccessManager *self = const_cast<QNetworkAccessManager *>(this); // We know we call a const slot
    QMetaObject::invokeMethod(self, "supportedSchemesImplementation", Qt::DirectConnection,
                              Q_RETURN_ARG(QStringList, schemes));
    schemes.removeDuplicates();
    return schemes;
}
 
QStringList QNetworkAccessManager::supportedSchemesImplementation() const
{
    Q_D(const QNetworkAccessManager);
 
    QStringList schemes = d->backendSupportedSchemes();
    // Those ones don't exist in backends
#if QT_CONFIG(http)
    schemes << QStringLiteral("http");
    schemes << QStringLiteral("unix+http");
    schemes << QStringLiteral("local+http");
#ifndef QT_NO_SSL
    if (QSslSocket::supportsSsl())
        schemes << QStringLiteral("https");
#endif
#endif
    schemes << QStringLiteral("data");
    return schemes;
}
 
void QNetworkAccessManager::clearAccessCache()
{
    QNetworkAccessManagerPrivate::clearAuthenticationCache(this);
    QNetworkAccessManagerPrivate::clearConnectionCache(this);
}
 
void QNetworkAccessManager::clearConnectionCache()
{
    QNetworkAccessManagerPrivate::clearConnectionCache(this);
}
 
 
bool QNetworkAccessManager::autoDeleteReplies() const
{
    return d_func()->autoDeleteReplies;
}
 
void QNetworkAccessManager::setAutoDeleteReplies(bool shouldAutoDelete)
{
    d_func()->autoDeleteReplies = shouldAutoDelete;
}
 
std::chrono::milliseconds QNetworkAccessManager::transferTimeoutAsDuration() const
{
    return d_func()->transferTimeout;
}
 
void QNetworkAccessManager::setTransferTimeout(std::chrono::milliseconds duration)
{
    d_func()->transferTimeout = duration;
}
 
void QNetworkAccessManagerPrivate::_q_replyFinished(QNetworkReply *reply)
{
    Q_Q(QNetworkAccessManager);
 
    emit q->finished(reply);
    if (reply->request().attribute(QNetworkRequest::AutoDeleteReplyOnFinishAttribute, false).toBool())
        QMetaObject::invokeMethod(reply, [reply] { reply->deleteLater(); }, Qt::QueuedConnection);
}
 
void QNetworkAccessManagerPrivate::_q_replyEncrypted(QNetworkReply *reply)
{
#ifndef QT_NO_SSL
    Q_Q(QNetworkAccessManager);
    emit q->encrypted(reply);
#else
    Q_UNUSED(reply);
#endif
}
 
void QNetworkAccessManagerPrivate::_q_replySslErrors(const QList<QSslError> &errors)
{
#ifndef QT_NO_SSL
    Q_Q(QNetworkAccessManager);
    QNetworkReply *reply = qobject_cast<QNetworkReply *>(q->sender());
    if (reply)
        emit q->sslErrors(reply, errors);
#else
    Q_UNUSED(errors);
#endif
}
 
#ifndef QT_NO_SSL
void QNetworkAccessManagerPrivate::_q_replyPreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator *authenticator)
{
    Q_Q(QNetworkAccessManager);
    QNetworkReply *reply = qobject_cast<QNetworkReply *>(q->sender());
    if (reply)
    emit q->preSharedKeyAuthenticationRequired(reply, authenticator);
}
#endif
 
QNetworkReply *QNetworkAccessManagerPrivate::postProcess(QNetworkReply *reply)
{
    Q_Q(QNetworkAccessManager);
    QNetworkReplyPrivate::setManager(reply, q);
    q->connect(reply, &QNetworkReply::finished, reply,
               [this, reply]() { _q_replyFinished(reply); });
#ifndef QT_NO_SSL
    /* In case we're compiled without SSL support, we don't have this signal and we need to
     * avoid getting a connection error. */
    q->connect(reply, &QNetworkReply::encrypted, reply,
               [this, reply]() { _q_replyEncrypted(reply); });
    q->connect(reply, SIGNAL(sslErrors(QList<QSslError>)), SLOT(_q_replySslErrors(QList<QSslError>)));
    q->connect(reply, SIGNAL(preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*)), SLOT(_q_replyPreSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*)));
#endif
 
    return reply;
}
 
void QNetworkAccessManagerPrivate::createCookieJar() const
{
    if (!cookieJarCreated) {
        // keep the ugly hack in here
        QNetworkAccessManagerPrivate *that = const_cast<QNetworkAccessManagerPrivate *>(this);
        that->cookieJar = new QNetworkCookieJar(that->q_func());
        that->cookieJarCreated = true;
    }
}
 
void QNetworkAccessManagerPrivate::authenticationRequired(QAuthenticator *authenticator,
                                                          QNetworkReply *reply,
                                                          bool synchronous,
                                                          QUrl &url,
                                                          QUrl *urlForLastAuthentication,
                                                          bool allowAuthenticationReuse)
{
    Q_Q(QNetworkAccessManager);
 
    // don't try the cache for the same URL twice in a row
    // being called twice for the same URL means the authentication failed
    // also called when last URL is empty, e.g. on first call
    if (allowAuthenticationReuse && (urlForLastAuthentication->isEmpty()
            || url != *urlForLastAuthentication)) {
        // if credentials are included in the url, then use them, unless they were already used
        if (!url.userName().isEmpty() && !url.password().isEmpty()
            && (url.userName() != authenticator->user()
                || url.password() != authenticator->password())) {
            authenticator->setUser(url.userName(QUrl::FullyDecoded));
            authenticator->setPassword(url.password(QUrl::FullyDecoded));
            *urlForLastAuthentication = url;
            authenticationManager->cacheCredentials(url, authenticator);
            return;
        }
 
        QNetworkAuthenticationCredential cred = authenticationManager->fetchCachedCredentials(url, authenticator);
        if (!cred.isNull()
            && (cred.user != authenticator->user() || cred.password != authenticator->password())) {
            authenticator->setUser(cred.user);
            authenticator->setPassword(cred.password);
            *urlForLastAuthentication = url;
            return;
        }
    }
 
    // if we emit a signal here in synchronous mode, the user might spin
    // an event loop, which might recurse and lead to problems
    if (synchronous)
        return;
 
    *urlForLastAuthentication = url;
    emit q->authenticationRequired(reply, authenticator);
    if (allowAuthenticationReuse)
        authenticationManager->cacheCredentials(url, authenticator);
}
 
#ifndef QT_NO_NETWORKPROXY
void QNetworkAccessManagerPrivate::proxyAuthenticationRequired(const QUrl &url,
                                                               const QNetworkProxy &proxy,
                                                               bool synchronous,
                                                               QAuthenticator *authenticator,
                                                               QNetworkProxy *lastProxyAuthentication)
{
    Q_Q(QNetworkAccessManager);
    QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(*authenticator);
    if (proxy != *lastProxyAuthentication && (!priv || !priv->hasFailed)) {
        QNetworkAuthenticationCredential cred = authenticationManager->fetchCachedProxyCredentials(proxy);
        if (!cred.isNull()) {
            authenticator->setUser(cred.user);
            authenticator->setPassword(cred.password);
            return;
        }
    }
 
#if defined(Q_OS_MACOS)
    //now we try to get the username and password from keychain
    //if not successful signal will be emitted
    QString username;
    QString password;
    if (getProxyAuth(proxy.hostName(), url.scheme(), username, password)) {
        // only cache the system credentials if they are correct (or if they have changed)
        // to not run into an endless loop in case they are wrong
        QNetworkAuthenticationCredential cred = authenticationManager->fetchCachedProxyCredentials(proxy);
        if (!priv->hasFailed || cred.user != username || cred.password != password) {
            authenticator->setUser(username);
            authenticator->setPassword(password);
            authenticationManager->cacheProxyCredentials(proxy, authenticator);
            return;
        }
    }
#else
    Q_UNUSED(url);
#endif
 
    // if we emit a signal here in synchronous mode, the user might spin
    // an event loop, which might recurse and lead to problems
    if (synchronous)
        return;
 
    *lastProxyAuthentication = proxy;
    emit q->proxyAuthenticationRequired(proxy, authenticator);
    authenticationManager->cacheProxyCredentials(proxy, authenticator);
}
 
QList<QNetworkProxy> QNetworkAccessManagerPrivate::queryProxy(const QNetworkProxyQuery &query)
{
    QList<QNetworkProxy> proxies;
    if (proxyFactory) {
        proxies = proxyFactory->queryProxy(query);
        if (proxies.isEmpty()) {
            qWarning("QNetworkAccessManager: factory %p has returned an empty result set",
                     proxyFactory);
            proxies << QNetworkProxy::NoProxy;
        }
    } else if (proxy.type() == QNetworkProxy::DefaultProxy) {
        // no proxy set, query the application
        return QNetworkProxyFactory::proxyForQuery(query);
    } else {
        proxies << proxy;
    }
 
    return proxies;
}
#endif
 
void QNetworkAccessManagerPrivate::clearAuthenticationCache(QNetworkAccessManager *manager)
{
    manager->d_func()->authenticationManager->clearCache();
}
 
void QNetworkAccessManagerPrivate::clearConnectionCache(QNetworkAccessManager *manager)
{
    manager->d_func()->objectCache.clear();
    manager->d_func()->destroyThread();
}
 
QNetworkAccessManagerPrivate::~QNetworkAccessManagerPrivate()
{
    destroyThread();
}
 
QThread * QNetworkAccessManagerPrivate::createThread()
{
    if (!thread) {
        thread = new QThread;
        thread->setObjectName(QStringLiteral("QNetworkAccessManager thread"));
        thread->start();
    }
    Q_ASSERT(thread);
    return thread;
}
 
void QNetworkAccessManagerPrivate::destroyThread()
{
    if (thread) {
        thread->quit();
        thread->wait(QDeadlineTimer(5000));
        if (thread->isFinished())
            delete thread;
        else
            QObject::connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
        thread = nullptr;
    }
}
 
 
#if QT_CONFIG(http) || defined(Q_OS_WASM)
 
QNetworkRequest QNetworkAccessManagerPrivate::prepareMultipart(const QNetworkRequest &request, QHttpMultiPart *multiPart)
{
    // copy the request, we probably need to add some headers
    QNetworkRequest newRequest(request);
    auto h = newRequest.headers();
 
    // add Content-Type header if not there already
    if (!h.contains(QHttpHeaders::WellKnownHeader::ContentType)) {
        QByteArray contentType;
        contentType.reserve(34 + multiPart->d_func()->boundary.size());
        contentType += "multipart/";
        switch (multiPart->d_func()->contentType) {
        case QHttpMultiPart::RelatedType:
            contentType += "related";
            break;
        case QHttpMultiPart::FormDataType:
            contentType += "form-data";
            break;
        case QHttpMultiPart::AlternativeType:
            contentType += "alternative";
            break;
        default:
            contentType += "mixed";
            break;
        }
        // putting the boundary into quotes, recommended in RFC 2046 section 5.1.1
        contentType += "; boundary=\"" + multiPart->d_func()->boundary + '"';
        h.append(QHttpHeaders::WellKnownHeader::ContentType, contentType);
    }
 
    // add MIME-Version header if not there already (we must include the header
    // if the message conforms to RFC 2045, see section 4 of that RFC)
    if (!h.contains(QHttpHeaders::WellKnownHeader::MIMEVersion))
        h.append(QHttpHeaders::WellKnownHeader::MIMEVersion, "1.0"_ba);
 
    newRequest.setHeaders(std::move(h));
 
    QIODevice *device = multiPart->d_func()->device;
    if (!device->isReadable()) {
        if (!device->isOpen()) {
            if (!device->open(QIODevice::ReadOnly))
                qWarning("could not open device for reading");
        } else {
            qWarning("device is not readable");
        }
    }
 
    return newRequest;
}
#endif // QT_CONFIG(http)
 
void QNetworkAccessManagerPrivate::ensureBackendPluginsLoaded()
{
    Q_CONSTINIT static QBasicMutex mutex;
    std::unique_lock locker(mutex);
    if (!qnabfLoader())
        return;
#if QT_CONFIG(library)
    qnabfLoader->update();
#endif
    int index = 0;
    while (qnabfLoader->instance(index))
        ++index;
}
 
QT_END_NAMESPACE
 
#include "moc_qnetworkaccessmanager.cpp"