qnetworkrequest.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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 "qnetworkrequest.h"
#include "qnetworkrequest_p.h"
#include "qplatformdefs.h"
#include "qnetworkcookie.h"
#include "qsslconfiguration.h"
#include "qhttpheadershelper_p.h"
#if QT_CONFIG(http)
#include "qhttp1configuration.h"
#include "qhttp2configuration.h"
#include "private/http2protocol_p.h"
#endif
 
#include "QtCore/qdatetime.h"
#include "QtCore/qlocale.h"
#include "QtCore/qshareddata.h"
#include "QtCore/qtimezone.h"
#include "QtCore/private/qduplicatetracker_p.h"
#include "QtCore/private/qtools_p.h"
 
#include <ctype.h>
#if QT_CONFIG(datestring)
# include <stdio.h>
#endif
 
#include <algorithm>
#include <q20algorithm.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
using namespace std::chrono_literals;
 
constexpr std::chrono::milliseconds QNetworkRequest::DefaultTransferTimeout;
 
QT_IMPL_METATYPE_EXTERN(QNetworkRequest)
QT_IMPL_METATYPE_EXTERN_TAGGED(QNetworkRequest::RedirectPolicy, QNetworkRequest__RedirectPolicy)
 
 
class QNetworkRequestPrivate: public QSharedData, public QNetworkHeadersPrivate
{
public:
    static const int maxRedirectCount = 50;
    inline QNetworkRequestPrivate()
        : priority(QNetworkRequest::NormalPriority)
#ifndef QT_NO_SSL
        , sslConfiguration(nullptr)
#endif
        , maxRedirectsAllowed(maxRedirectCount)
    { qRegisterMetaType<QNetworkRequest>(); }
    ~QNetworkRequestPrivate()
    {
#ifndef QT_NO_SSL
        delete sslConfiguration;
#endif
    }
 
 
    QNetworkRequestPrivate(const QNetworkRequestPrivate &other)
        : QSharedData(other), QNetworkHeadersPrivate(other)
    {
        url = other.url;
        priority = other.priority;
        maxRedirectsAllowed = other.maxRedirectsAllowed;
#ifndef QT_NO_SSL
        sslConfiguration = nullptr;
        if (other.sslConfiguration)
            sslConfiguration = new QSslConfiguration(*other.sslConfiguration);
#endif
        peerVerifyName = other.peerVerifyName;
#if QT_CONFIG(http)
        h1Configuration = other.h1Configuration;
        h2Configuration = other.h2Configuration;
        decompressedSafetyCheckThreshold = other.decompressedSafetyCheckThreshold;
#endif
        transferTimeout = other.transferTimeout;
    }
 
    inline bool operator==(const QNetworkRequestPrivate &other) const
    {
        return url == other.url &&
            priority == other.priority &&
            attributes == other.attributes &&
            maxRedirectsAllowed == other.maxRedirectsAllowed &&
            peerVerifyName == other.peerVerifyName
#if QT_CONFIG(http)
            && h1Configuration == other.h1Configuration
            && h2Configuration == other.h2Configuration
            && decompressedSafetyCheckThreshold == other.decompressedSafetyCheckThreshold
#endif
            && transferTimeout == other.transferTimeout
            && QHttpHeadersHelper::compareStrict(httpHeaders, other.httpHeaders)
            ;
        // don't compare cookedHeaders
    }
 
    QUrl url;
    QNetworkRequest::Priority priority;
#ifndef QT_NO_SSL
    mutable QSslConfiguration *sslConfiguration;
#endif
    int maxRedirectsAllowed;
    QString peerVerifyName;
#if QT_CONFIG(http)
    QHttp1Configuration h1Configuration;
    QHttp2Configuration h2Configuration;
    qint64 decompressedSafetyCheckThreshold = 10ll * 1024ll * 1024ll;
#endif
    std::chrono::milliseconds transferTimeout = 0ms;
};
 
QNetworkRequest::QNetworkRequest()
    : d(new QNetworkRequestPrivate)
{
#if QT_CONFIG(http)
    // Initial values proposed by RFC 7540 are quite draconian, but we
    // know about servers configured with this value as maximum possible,
    // rejecting our SETTINGS frame and sending us a GOAWAY frame with the
    // flow control error set. If this causes a problem - the app should
    // set a proper configuration. We'll use our defaults, as documented.
    d->h2Configuration.setStreamReceiveWindowSize(Http2::qtDefaultStreamReceiveWindowSize);
    d->h2Configuration.setSessionReceiveWindowSize(Http2::maxSessionReceiveWindowSize);
    d->h2Configuration.setServerPushEnabled(false);
#endif // QT_CONFIG(http)
}
 
QNetworkRequest::QNetworkRequest(const QUrl &url)
    : QNetworkRequest()
{
    d->url = url;
}
 
QNetworkRequest::QNetworkRequest(const QNetworkRequest &other)
    : d(other.d)
{
}
 
QNetworkRequest::~QNetworkRequest()
{
    // QSharedDataPointer auto deletes
    d = nullptr;
}
 
bool QNetworkRequest::operator==(const QNetworkRequest &other) const
{
    return d == other.d || *d == *other.d;
}
 
QNetworkRequest &QNetworkRequest::operator=(const QNetworkRequest &other)
{
    d = other.d;
    return *this;
}
 
QUrl QNetworkRequest::url() const
{
    return d->url;
}
 
void QNetworkRequest::setUrl(const QUrl &url)
{
    d->url = url;
}
 
QHttpHeaders QNetworkRequest::headers() const
{
    return d->headers();
}
 
void QNetworkRequest::setHeaders(QHttpHeaders &&newHeaders)
{
    d->setHeaders(std::move(newHeaders));
}
 
void QNetworkRequest::setHeaders(const QHttpHeaders &newHeaders)
{
    d->setHeaders(newHeaders);
}
 
QVariant QNetworkRequest::header(KnownHeaders header) const
{
    return d->cookedHeaders.value(header);
}
 
void QNetworkRequest::setHeader(KnownHeaders header, const QVariant &value)
{
    d->setCookedHeader(header, value);
}
 
bool QNetworkRequest::hasRawHeader(QAnyStringView headerName) const
{
    return d->headers().contains(headerName);
}
 
QByteArray QNetworkRequest::rawHeader(QAnyStringView headerName) const
{
    return d->rawHeader(headerName);
}
 
QList<QByteArray> QNetworkRequest::rawHeaderList() const
{
    return d->rawHeadersKeys();
}
 
void QNetworkRequest::setRawHeader(const QByteArray &headerName, const QByteArray &headerValue)
{
    d->setRawHeader(headerName, headerValue);
}
 
QVariant QNetworkRequest::attribute(Attribute code, const QVariant &defaultValue) const
{
    return d->attributes.value(code, defaultValue);
}
 
void QNetworkRequest::setAttribute(Attribute code, const QVariant &value)
{
    if (value.isValid())
        d->attributes.insert(code, value);
    else
        d->attributes.remove(code);
}
 
#ifndef QT_NO_SSL
QSslConfiguration QNetworkRequest::sslConfiguration() const
{
    if (!d->sslConfiguration)
        d->sslConfiguration = new QSslConfiguration(QSslConfiguration::defaultConfiguration());
    return *d->sslConfiguration;
}
 
void QNetworkRequest::setSslConfiguration(const QSslConfiguration &config)
{
    if (!d->sslConfiguration)
        d->sslConfiguration = new QSslConfiguration(config);
    else
        *d->sslConfiguration = config;
}
#endif
 
void QNetworkRequest::setOriginatingObject(QObject *object)
{
    d->originatingObject = object;
}
 
QObject *QNetworkRequest::originatingObject() const
{
    return d->originatingObject.data();
}
 
QNetworkRequest::Priority QNetworkRequest::priority() const
{
    return d->priority;
}
 
void QNetworkRequest::setPriority(Priority priority)
{
    d->priority = priority;
}
 
int QNetworkRequest::maximumRedirectsAllowed() const
{
    return d->maxRedirectsAllowed;
}
 
void QNetworkRequest::setMaximumRedirectsAllowed(int maxRedirectsAllowed)
{
    d->maxRedirectsAllowed = maxRedirectsAllowed;
}
 
QString QNetworkRequest::peerVerifyName() const
{
    return d->peerVerifyName;
}
 
void QNetworkRequest::setPeerVerifyName(const QString &peerName)
{
    d->peerVerifyName = peerName;
}
 
#if QT_CONFIG(http)
QHttp1Configuration QNetworkRequest::http1Configuration() const
{
    return d->h1Configuration;
}
void QNetworkRequest::setHttp1Configuration(const QHttp1Configuration &configuration)
{
    d->h1Configuration = configuration;
}
 
QHttp2Configuration QNetworkRequest::http2Configuration() const
{
    return d->h2Configuration;
}
 
void QNetworkRequest::setHttp2Configuration(const QHttp2Configuration &configuration)
{
    d->h2Configuration = configuration;
}
 
qint64 QNetworkRequest::decompressedSafetyCheckThreshold() const
{
    return d->decompressedSafetyCheckThreshold;
}
 
void QNetworkRequest::setDecompressedSafetyCheckThreshold(qint64 threshold)
{
    d->decompressedSafetyCheckThreshold = threshold;
}
#endif // QT_CONFIG(http)
 
#if QT_CONFIG(http) || defined (Q_OS_WASM)
std::chrono::milliseconds QNetworkRequest::transferTimeoutAsDuration() const
{
    return d->transferTimeout;
}
 
void QNetworkRequest::setTransferTimeout(std::chrono::milliseconds duration)
{
    d->transferTimeout = duration;
}
#endif // QT_CONFIG(http) || defined (Q_OS_WASM)
 
namespace  {
 
struct HeaderPair {
    QHttpHeaders::WellKnownHeader wellKnownHeader;
    QNetworkRequest::KnownHeaders knownHeader;
};
 
constexpr bool operator<(const HeaderPair &lhs, const HeaderPair &rhs)
{
    return lhs.wellKnownHeader < rhs.wellKnownHeader;
}
 
constexpr bool operator<(const HeaderPair &lhs, QHttpHeaders::WellKnownHeader rhs)
{
    return lhs.wellKnownHeader < rhs;
}
 
constexpr bool operator<(QHttpHeaders::WellKnownHeader lhs, const HeaderPair &rhs)
{
    return lhs < rhs.wellKnownHeader;
}
 
} // anonymous namespace
 
static constexpr HeaderPair knownHeadersArr[] = {
    { QHttpHeaders::WellKnownHeader::ContentDisposition, QNetworkRequest::KnownHeaders::ContentDispositionHeader },
    { QHttpHeaders::WellKnownHeader::ContentLength,      QNetworkRequest::KnownHeaders::ContentLengthHeader },
    { QHttpHeaders::WellKnownHeader::ContentType,        QNetworkRequest::KnownHeaders::ContentTypeHeader },
    { QHttpHeaders::WellKnownHeader::Cookie,             QNetworkRequest::KnownHeaders::CookieHeader },
    { QHttpHeaders::WellKnownHeader::ETag,               QNetworkRequest::KnownHeaders::ETagHeader },
    { QHttpHeaders::WellKnownHeader::IfMatch ,           QNetworkRequest::KnownHeaders::IfMatchHeader },
    { QHttpHeaders::WellKnownHeader::IfModifiedSince,    QNetworkRequest::KnownHeaders::IfModifiedSinceHeader },
    { QHttpHeaders::WellKnownHeader::IfNoneMatch,        QNetworkRequest::KnownHeaders::IfNoneMatchHeader },
    { QHttpHeaders::WellKnownHeader::LastModified,       QNetworkRequest::KnownHeaders::LastModifiedHeader},
    { QHttpHeaders::WellKnownHeader::Location,           QNetworkRequest::KnownHeaders::LocationHeader},
    { QHttpHeaders::WellKnownHeader::Server,             QNetworkRequest::KnownHeaders::ServerHeader },
    { QHttpHeaders::WellKnownHeader::SetCookie,          QNetworkRequest::KnownHeaders::SetCookieHeader },
    { QHttpHeaders::WellKnownHeader::UserAgent,          QNetworkRequest::KnownHeaders::UserAgentHeader }
};
 
static_assert(std::size(knownHeadersArr) == size_t(QNetworkRequest::KnownHeaders::NumKnownHeaders));
static_assert(q20::is_sorted(std::begin(knownHeadersArr), std::end(knownHeadersArr)));
 
static std::optional<QNetworkRequest::KnownHeaders> toKnownHeader(QHttpHeaders::WellKnownHeader key)
{
    const auto it = std::lower_bound(std::begin(knownHeadersArr), std::end(knownHeadersArr), key);
    if (it == std::end(knownHeadersArr) || key < *it)
        return std::nullopt;
    return it->knownHeader;
}
 
static std::optional<QHttpHeaders::WellKnownHeader> toWellKnownHeader(QNetworkRequest::KnownHeaders key)
{
    auto pred = [key](const HeaderPair &pair) { return pair.knownHeader == key; };
    const auto it = std::find_if(std::begin(knownHeadersArr), std::end(knownHeadersArr), pred);
    if (it == std::end(knownHeadersArr))
        return std::nullopt;
    return it->wellKnownHeader;
}
 
static QByteArray makeCookieHeader(const QList<QNetworkCookie> &cookies,
                                   QNetworkCookie::RawForm type,
                                   QByteArrayView separator)
{
    QByteArray result;
    for (const QNetworkCookie &cookie : cookies) {
        result += cookie.toRawForm(type);
        result += separator;
    }
    if (!result.isEmpty())
        result.chop(separator.size());
    return result;
}
 
static QByteArray makeCookieHeader(const QVariant &value, QNetworkCookie::RawForm type,
                                   QByteArrayView separator)
{
    const QList<QNetworkCookie> *cookies = get_if<QList<QNetworkCookie>>(&value);
    if (!cookies)
        return {};
    return makeCookieHeader(*cookies, type, separator);
}
 
static QByteArray headerValue(QNetworkRequest::KnownHeaders header, const QVariant &value)
{
    switch (header) {
    case QNetworkRequest::ContentTypeHeader:
    case QNetworkRequest::ContentLengthHeader:
    case QNetworkRequest::ContentDispositionHeader:
    case QNetworkRequest::UserAgentHeader:
    case QNetworkRequest::ServerHeader:
    case QNetworkRequest::ETagHeader:
    case QNetworkRequest::IfMatchHeader:
    case QNetworkRequest::IfNoneMatchHeader:
        return value.toByteArray();
 
    case QNetworkRequest::LocationHeader:
        switch (value.userType()) {
        case QMetaType::QUrl:
            return value.toUrl().toEncoded();
 
        default:
            return value.toByteArray();
        }
 
    case QNetworkRequest::LastModifiedHeader:
    case QNetworkRequest::IfModifiedSinceHeader:
        switch (value.userType()) {
            // Generate RFC 1123/822 dates:
        case QMetaType::QDate:
            return QNetworkHeadersPrivate::toHttpDate(value.toDate().startOfDay(QTimeZone::UTC));
        case QMetaType::QDateTime:
            return QNetworkHeadersPrivate::toHttpDate(value.toDateTime());
 
        default:
            return value.toByteArray();
        }
 
    case QNetworkRequest::CookieHeader:
        return makeCookieHeader(value, QNetworkCookie::NameAndValueOnly, "; ");
 
    case QNetworkRequest::SetCookieHeader:
        return makeCookieHeader(value, QNetworkCookie::Full, ", ");
 
    default:
        Q_UNREACHABLE_RETURN({});
    }
}
 
static int parseHeaderName(QByteArrayView headerName)
{
    if (headerName.isEmpty())
        return -1;
 
    auto is = [headerName](QByteArrayView what) {
        return headerName.compare(what, Qt::CaseInsensitive) == 0;
    };
 
    switch (QtMiscUtils::toAsciiLower(headerName.front())) {
    case 'c':
        if (is("content-type"))
            return QNetworkRequest::ContentTypeHeader;
        else if (is("content-length"))
            return QNetworkRequest::ContentLengthHeader;
        else if (is("cookie"))
            return QNetworkRequest::CookieHeader;
        else if (is("content-disposition"))
            return QNetworkRequest::ContentDispositionHeader;
        break;
 
    case 'e':
        if (is("etag"))
            return QNetworkRequest::ETagHeader;
        break;
 
    case 'i':
        if (is("if-modified-since"))
            return QNetworkRequest::IfModifiedSinceHeader;
        if (is("if-match"))
            return QNetworkRequest::IfMatchHeader;
        if (is("if-none-match"))
            return QNetworkRequest::IfNoneMatchHeader;
        break;
 
    case 'l':
        if (is("location"))
            return QNetworkRequest::LocationHeader;
        else if (is("last-modified"))
            return QNetworkRequest::LastModifiedHeader;
        break;
 
    case 's':
        if (is("set-cookie"))
            return QNetworkRequest::SetCookieHeader;
        else if (is("server"))
            return QNetworkRequest::ServerHeader;
        break;
 
    case 'u':
        if (is("user-agent"))
            return QNetworkRequest::UserAgentHeader;
        break;
    }
 
    return -1; // nothing found
}
 
static QVariant parseHttpDate(QByteArrayView raw)
{
    QDateTime dt = QNetworkHeadersPrivate::fromHttpDate(raw);
    if (dt.isValid())
        return dt;
    return QVariant();          // transform an invalid QDateTime into a null QVariant
}
 
static QList<QNetworkCookie> parseCookieHeader(QByteArrayView raw)
{
    QList<QNetworkCookie> result;
    for (auto cookie : QLatin1StringView(raw).tokenize(';'_L1)) {
        QList<QNetworkCookie> parsed = QNetworkCookie::parseCookies(cookie.trimmed());
        if (parsed.size() != 1)
            return {};  // invalid Cookie: header
 
        result += parsed;
    }
 
    return result;
}
 
static QVariant parseETag(QByteArrayView raw)
{
    const QByteArrayView trimmed = raw.trimmed();
    if (!trimmed.startsWith('"') && !trimmed.startsWith(R"(W/")"))
        return QVariant();
 
    if (!trimmed.endsWith('"'))
        return QVariant();
 
    return QString::fromLatin1(trimmed);
}
 
template<typename T>
static QStringList parseMatchImpl(QByteArrayView raw, T op)
{
    const QByteArrayView trimmedRaw = raw.trimmed();
    if (trimmedRaw == "*")
        return QStringList(QStringLiteral("*"));
 
    QStringList tags;
    for (auto &element : QLatin1StringView(trimmedRaw).tokenize(','_L1)) {
        if (const auto trimmed = element.trimmed(); op(trimmed))
            tags += QString::fromLatin1(trimmed);
    }
    return tags;
}
 
 
static QStringList parseIfMatch(QByteArrayView raw)
{
    return parseMatchImpl(raw, [](QByteArrayView element) {
        return element.startsWith('"') && element.endsWith('"');
    });
}
 
static QStringList parseIfNoneMatch(QByteArrayView raw)
{
    return parseMatchImpl(raw, [](QByteArrayView element) {
        return (element.startsWith('"') || element.startsWith(R"(W/")")) && element.endsWith('"');
    });
}
 
 
static QVariant parseHeaderValue(QNetworkRequest::KnownHeaders header, QByteArrayView value)
{
    // header is always a valid value
    switch (header) {
    case QNetworkRequest::UserAgentHeader:
    case QNetworkRequest::ServerHeader:
    case QNetworkRequest::ContentTypeHeader:
    case QNetworkRequest::ContentDispositionHeader:
        // copy exactly, convert to QString
        return QString::fromLatin1(value);
 
    case QNetworkRequest::ContentLengthHeader: {
        bool ok;
        qint64 result = QByteArrayView(value).trimmed().toLongLong(&ok);
        if (ok)
            return result;
        return QVariant();
    }
 
    case QNetworkRequest::LocationHeader: {
        QUrl result = QUrl::fromEncoded(value, QUrl::StrictMode);
        if (result.isValid() && !result.scheme().isEmpty())
            return result;
        return QVariant();
    }
 
    case QNetworkRequest::LastModifiedHeader:
    case QNetworkRequest::IfModifiedSinceHeader:
        return parseHttpDate(value);
 
    case QNetworkRequest::ETagHeader:
        return parseETag(value);
 
    case QNetworkRequest::IfMatchHeader:
        return parseIfMatch(value);
 
    case QNetworkRequest::IfNoneMatchHeader:
        return parseIfNoneMatch(value);
 
    case QNetworkRequest::CookieHeader:
        return QVariant::fromValue(parseCookieHeader(value));
 
    case QNetworkRequest::SetCookieHeader:
        return QVariant::fromValue(QNetworkCookie::parseCookies(value));
 
    default:
        Q_UNREACHABLE_RETURN({});
    }
}
 
static QVariant parseHeaderValue(QNetworkRequest::KnownHeaders header, QList<QByteArray> values)
{
    if (values.empty())
        return QVariant();
 
    // header is always a valid value
    switch (header) {
    case QNetworkRequest::IfMatchHeader: {
        QStringList res;
        for (const auto &val : values)
            res << parseIfMatch(val);
        return res;
    }
    case QNetworkRequest::IfNoneMatchHeader: {
        QStringList res;
        for (const auto &val : values)
            res << parseIfNoneMatch(val);
        return res;
    }
    case QNetworkRequest::CookieHeader: {
        auto listOpt = QNetworkHeadersPrivate::toCookieList(values);
        return listOpt.has_value() ? QVariant::fromValue(listOpt.value()) : QVariant();
    }
    case QNetworkRequest::SetCookieHeader: {
        QList<QNetworkCookie> res;
        for (const auto &val : values)
            res << QNetworkCookie::parseCookies(val);
        return QVariant::fromValue(res);
    }
    default:
        return parseHeaderValue(header, values.first());
    }
    return QVariant();
}
 
static bool isSetCookie(QByteArrayView name)
{
    return name.compare(QHttpHeaders::wellKnownHeaderName(QHttpHeaders::WellKnownHeader::SetCookie),
                        Qt::CaseInsensitive) == 0;
}
 
static bool isSetCookie(QHttpHeaders::WellKnownHeader name)
{
    return name == QHttpHeaders::WellKnownHeader::SetCookie;
}
 
template<class HeaderName>
static void setFromRawHeader(QHttpHeaders &headers, HeaderName header,
                             QByteArrayView value)
{
    headers.removeAll(header);
 
    if (value.isNull())
        // only wanted to erase key
        return;
 
    if (isSetCookie(header)) {
        for (auto cookie : QLatin1StringView(value).tokenize('\n'_L1))
            headers.append(QHttpHeaders::WellKnownHeader::SetCookie, cookie);
    } else {
        headers.append(header, value);
    }
}
 
const QNetworkHeadersPrivate::RawHeadersList &QNetworkHeadersPrivate::allRawHeaders() const
{
    if (rawHeaderCache.isCached)
        return rawHeaderCache.headersList;
 
    rawHeaderCache.headersList = fromHttpToRaw(httpHeaders);
    rawHeaderCache.isCached = true;
    return rawHeaderCache.headersList;
}
 
QList<QByteArray> QNetworkHeadersPrivate::rawHeadersKeys() const
{
    if (httpHeaders.isEmpty())
        return {};
 
    QList<QByteArray> result;
    result.reserve(httpHeaders.size());
    QDuplicateTracker<QByteArray> seen(httpHeaders.size());
 
    for (qsizetype i = 0; i < httpHeaders.size(); i++) {
        const auto nameL1 = httpHeaders.nameAt(i);
        const auto name = QByteArray(nameL1.data(), nameL1.size());
        if (seen.hasSeen(name))
            continue;
 
        result << name;
    }
 
    return result;
}
 
QByteArray QNetworkHeadersPrivate::rawHeader(QAnyStringView headerName) const
{
    QByteArrayView setCookieStr = QHttpHeaders::wellKnownHeaderName(
            QHttpHeaders::WellKnownHeader::SetCookie);
    if (QAnyStringView::compare(headerName, setCookieStr, Qt::CaseInsensitive) != 0)
        return httpHeaders.combinedValue(headerName);
 
    QByteArray result;
    const char* separator = "";
    for (qsizetype i = 0; i < httpHeaders.size(); ++i) {
        if (QAnyStringView::compare(httpHeaders.nameAt(i), headerName, Qt::CaseInsensitive) == 0) {
            result.append(separator);
            result.append(httpHeaders.valueAt(i));
            separator = "\n";
        }
    }
    return result;
}
 
void QNetworkHeadersPrivate::setRawHeader(const QByteArray &key, const QByteArray &value)
{
    if (key.isEmpty())
        // refuse to accept an empty raw header
        return;
 
    setFromRawHeader(httpHeaders, key, value);
    parseAndSetHeader(key, value);
 
    invalidateHeaderCache();
}
 
void QNetworkHeadersPrivate::setCookedHeader(QNetworkRequest::KnownHeaders header,
                                             const QVariant &value)
{
    const auto wellKnownOpt = toWellKnownHeader(header);
    if (!wellKnownOpt) {
        // verifies that \a header is a known value
        qWarning("QNetworkRequest::setHeader: invalid header value KnownHeader(%d) received", header);
        return;
    }
 
    if (value.isNull()) {
        httpHeaders.removeAll(wellKnownOpt.value());
        cookedHeaders.remove(header);
    } else {
        QByteArray rawValue = headerValue(header, value);
        if (rawValue.isEmpty()) {
            qWarning("QNetworkRequest::setHeader: QVariant of type %s cannot be used with header %s",
                     value.typeName(),
                     QHttpHeaders::wellKnownHeaderName(wellKnownOpt.value()).constData());
            return;
        }
 
        setFromRawHeader(httpHeaders, wellKnownOpt.value(), rawValue);
        cookedHeaders.insert(header, value);
    }
 
    invalidateHeaderCache();
}
 
QHttpHeaders QNetworkHeadersPrivate::headers() const
{
    return httpHeaders;
}
 
void QNetworkHeadersPrivate::setHeaders(const QHttpHeaders &newHeaders)
{
    httpHeaders = newHeaders;
    setCookedFromHttp(httpHeaders);
    invalidateHeaderCache();
}
 
void QNetworkHeadersPrivate::setHeaders(QHttpHeaders &&newHeaders)
{
    httpHeaders = std::move(newHeaders);
    setCookedFromHttp(httpHeaders);
    invalidateHeaderCache();
}
 
void QNetworkHeadersPrivate::setHeader(QHttpHeaders::WellKnownHeader name, QByteArrayView value)
{
    httpHeaders.replaceOrAppend(name, value);
 
    // set cooked header
    const auto knownHeaderOpt = toKnownHeader(name);
    if (knownHeaderOpt)
        parseAndSetHeader(knownHeaderOpt.value(), value);
 
    invalidateHeaderCache();
}
 
void QNetworkHeadersPrivate::clearHeaders()
{
    httpHeaders.clear();
    cookedHeaders.clear();
    invalidateHeaderCache();
}
 
void QNetworkHeadersPrivate::parseAndSetHeader(QByteArrayView key, QByteArrayView value)
{
    // is it a known header?
    const int parsedKeyAsInt = parseHeaderName(key);
    if (parsedKeyAsInt != -1) {
        const QNetworkRequest::KnownHeaders parsedKey
                = static_cast<QNetworkRequest::KnownHeaders>(parsedKeyAsInt);
        parseAndSetHeader(parsedKey, value);
    }
}
 
void QNetworkHeadersPrivate::parseAndSetHeader(QNetworkRequest::KnownHeaders key,
                                               QByteArrayView value)
{
    if (value.isNull()) {
        cookedHeaders.remove(key);
    } else if (key == QNetworkRequest::ContentLengthHeader
               && cookedHeaders.contains(QNetworkRequest::ContentLengthHeader)) {
        // Only set the cooked header "Content-Length" once.
        // See bug QTBUG-15311
    } else {
        cookedHeaders.insert(key, parseHeaderValue(key, value));
    }
}
 
// Fast month string to int conversion. This code
// assumes that the Month name is correct and that
// the string is at least three chars long.
static int name_to_month(const char* month_str)
{
    switch (month_str[0]) {
    case 'J':
        switch (month_str[1]) {
        case 'a':
            return 1;
        case 'u':
            switch (month_str[2] ) {
            case 'n':
                return 6;
            case 'l':
                return 7;
            }
        }
        break;
    case 'F':
        return 2;
    case 'M':
        switch (month_str[2] ) {
        case 'r':
            return 3;
        case 'y':
            return 5;
        }
        break;
    case 'A':
        switch (month_str[1]) {
        case 'p':
            return 4;
        case 'u':
            return 8;
        }
        break;
    case 'O':
        return 10;
    case 'S':
        return 9;
    case 'N':
        return 11;
    case 'D':
        return 12;
    }
 
    return 0;
}
 
QDateTime QNetworkHeadersPrivate::fromHttpDate(QByteArrayView value)
{
    // HTTP dates have three possible formats:
    //  RFC 1123/822      -   ddd, dd MMM yyyy hh:mm:ss "GMT"
    //  RFC 850           -   dddd, dd-MMM-yy hh:mm:ss "GMT"
    //  ANSI C's asctime  -   ddd MMM d hh:mm:ss yyyy
    // We only handle them exactly. If they deviate, we bail out.
 
    int pos = value.indexOf(',');
    QDateTime dt;
#if QT_CONFIG(datestring)
    if (pos == -1) {
        // no comma -> asctime(3) format
        dt = QDateTime::fromString(QString::fromLatin1(value), Qt::TextDate);
    } else {
        // Use sscanf over QLocal/QDateTimeParser for speed reasons. See the
        // Qt WebKit performance benchmarks to get an idea.
        if (pos == 3) {
            char month_name[4];
            int day, year, hour, minute, second;
#ifdef Q_CC_MSVC
            // Use secure version to avoid compiler warning
            if (sscanf_s(value.constData(), "%*3s, %d %3s %d %d:%d:%d 'GMT'", &day, month_name, 4, &year, &hour, &minute, &second) == 6)
#else
            // The POSIX secure mode is %ms (which allocates memory), too bleeding edge for now
            // In any case this is already safe as field width is specified.
            if (sscanf(value.constData(), "%*3s, %d %3s %d %d:%d:%d 'GMT'", &day, month_name, &year, &hour, &minute, &second) == 6)
#endif
                dt = QDateTime(QDate(year, name_to_month(month_name), day), QTime(hour, minute, second));
        } else {
            QLocale c = QLocale::c();
            // eat the weekday, the comma and the space following it
            QString sansWeekday = QString::fromLatin1(value.constData() + pos + 2);
            // must be RFC 850 date
            dt = c.toDateTime(sansWeekday, "dd-MMM-yy hh:mm:ss 'GMT'"_L1);
        }
    }
#endif // datestring
 
    if (dt.isValid())
        dt.setTimeZone(QTimeZone::UTC);
    return dt;
}
 
QByteArray QNetworkHeadersPrivate::toHttpDate(const QDateTime &dt)
{
    return QLocale::c().toString(dt.toUTC(), u"ddd, dd MMM yyyy hh:mm:ss 'GMT'").toLatin1();
}
 
QNetworkHeadersPrivate::RawHeadersList QNetworkHeadersPrivate::fromHttpToRaw(
        const QHttpHeaders &headers)
{
    if (headers.isEmpty())
        return {};
 
    QNetworkHeadersPrivate::RawHeadersList list;
    QHash<QByteArray, qsizetype> nameToIndex;
    list.reserve(headers.size());
    nameToIndex.reserve(headers.size());
 
    for (qsizetype i = 0; i < headers.size(); ++i) {
        const auto nameL1 = headers.nameAt(i);
        const auto value = headers.valueAt(i);
 
        const bool isSetCookie = nameL1 == QHttpHeaders::wellKnownHeaderName(
                                         QHttpHeaders::WellKnownHeader::SetCookie);
 
        const auto name = QByteArray(nameL1.data(), nameL1.size());
        if (auto it = nameToIndex.find(name); it != nameToIndex.end()) {
            list[it.value()].second += isSetCookie ? "\n" : ", ";
            list[it.value()].second += value;
        } else {
            nameToIndex[name] = list.size();
            list.emplaceBack(name, value.toByteArray());
        }
    }
 
    return list;
}
 
QHttpHeaders QNetworkHeadersPrivate::fromRawToHttp(const RawHeadersList &raw)
{
    if (raw.empty())
        return {};
 
    QHttpHeaders headers;
    headers.reserve(raw.size());
 
    for (const auto &[key, value] : raw) {
        const bool isSetCookie = key.compare(QHttpHeaders::wellKnownHeaderName(
                                             QHttpHeaders::WellKnownHeader::SetCookie),
                                             Qt::CaseInsensitive) == 0;
        if (isSetCookie) {
            for (auto header : QLatin1StringView(value).tokenize('\n'_L1))
                headers.append(key, header);
        } else {
            headers.append(key, value);
        }
    }
 
    return headers;
}
 
std::optional<qint64> QNetworkHeadersPrivate::toInt(QByteArrayView value)
{
    if (value.empty())
        return std::nullopt;
 
    bool ok;
    qint64 res = value.toLongLong(&ok);
    if (ok)
        return res;
    return std::nullopt;
}
 
std::optional<QNetworkHeadersPrivate::NetworkCookieList> QNetworkHeadersPrivate::toSetCookieList(
        const QList<QByteArray> &values)
{
    if (values.empty())
        return std::nullopt;
 
    QList<QNetworkCookie> cookies;
    for (const auto &s : values)
        cookies += QNetworkCookie::parseCookies(s);
 
    if (cookies.empty())
        return std::nullopt;
    return cookies;
}
 
QByteArray QNetworkHeadersPrivate::fromCookieList(const QList<QNetworkCookie> &cookies)
{
    return makeCookieHeader(cookies, QNetworkCookie::NameAndValueOnly, "; ");
}
 
std::optional<QNetworkHeadersPrivate::NetworkCookieList> QNetworkHeadersPrivate::toCookieList(
        const QList<QByteArray> &values)
{
    if (values.empty())
        return std::nullopt;
 
    QList<QNetworkCookie> cookies;
    for (const auto &s : values)
        cookies += parseCookieHeader(s);
 
    if (cookies.empty())
        return std::nullopt;
    return cookies;
}
 
void QNetworkHeadersPrivate::invalidateHeaderCache()
{
    rawHeaderCache.headersList.clear();
    rawHeaderCache.isCached = false;
}
 
void QNetworkHeadersPrivate::setCookedFromHttp(const QHttpHeaders &newHeaders)
{
    cookedHeaders.clear();
 
    QMap<QNetworkRequest::KnownHeaders, QList<QByteArray>> multipleHeadersMap;
    for (int i = 0; i < newHeaders.size(); ++i) {
        const auto name = newHeaders.nameAt(i);
        const auto value = newHeaders.valueAt(i);
 
        const int parsedKeyAsInt = parseHeaderName(name);
        if (parsedKeyAsInt == -1)
            continue;
 
        const QNetworkRequest::KnownHeaders parsedKey
                = static_cast<QNetworkRequest::KnownHeaders>(parsedKeyAsInt);
 
        auto &list = multipleHeadersMap[parsedKey];
        list.append(value.toByteArray());
    }
 
    for (auto i = multipleHeadersMap.cbegin(), end = multipleHeadersMap.cend(); i != end; ++i)
        cookedHeaders.insert(i.key(), parseHeaderValue(i.key(), i.value()));
}
 
QT_END_NAMESPACE
 
#include "moc_qnetworkrequest.cpp"