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"
#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/qtools_p.h"
 
#include <ctype.h>
#if QT_CONFIG(datestring)
# include <stdio.h>
#endif
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
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)
        , transferTimeout(0)
    { 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 &&
            rawHeaders == other.rawHeaders &&
            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
            ;
        // 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
    int transferTimeout;
};
 
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;
}
 
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(const QByteArray &headerName) const
{
    return d->findRawHeader(headerName) != d->rawHeaders.constEnd();
}
 
QByteArray QNetworkRequest::rawHeader(const QByteArray &headerName) const
{
    QNetworkHeadersPrivate::RawHeadersList::ConstIterator it =
        d->findRawHeader(headerName);
    if (it != d->rawHeaders.constEnd())
        return it->second;
    return QByteArray();
}
 
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)
int QNetworkRequest::transferTimeout() const
{
    return d->transferTimeout;
}
 
void QNetworkRequest::setTransferTimeout(int timeout)
{
    d->transferTimeout = timeout;
}
#endif // QT_CONFIG(http) || defined (Q_OS_WASM)
 
static QByteArray headerName(QNetworkRequest::KnownHeaders header)
{
    switch (header) {
    case QNetworkRequest::ContentTypeHeader:
        return "Content-Type";
 
    case QNetworkRequest::ContentLengthHeader:
        return "Content-Length";
 
    case QNetworkRequest::LocationHeader:
        return "Location";
 
    case QNetworkRequest::LastModifiedHeader:
        return "Last-Modified";
 
    case QNetworkRequest::IfModifiedSinceHeader:
        return "If-Modified-Since";
 
    case QNetworkRequest::ETagHeader:
        return "ETag";
 
    case QNetworkRequest::IfMatchHeader:
        return "If-Match";
 
    case QNetworkRequest::IfNoneMatchHeader:
        return "If-None-Match";
 
    case QNetworkRequest::CookieHeader:
        return "Cookie";
 
    case QNetworkRequest::SetCookieHeader:
        return "Set-Cookie";
 
    case QNetworkRequest::ContentDispositionHeader:
        return "Content-Disposition";
 
    case QNetworkRequest::UserAgentHeader:
        return "User-Agent";
 
    case QNetworkRequest::ServerHeader:
        return "Server";
 
    // no default:
    // if new values are added, this will generate a compiler warning
    }
 
    return QByteArray();
}
 
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: {
        QList<QNetworkCookie> cookies = qvariant_cast<QList<QNetworkCookie> >(value);
        if (cookies.isEmpty() && value.userType() == qMetaTypeId<QNetworkCookie>())
            cookies << qvariant_cast<QNetworkCookie>(value);
 
        QByteArray result;
        bool first = true;
        for (const QNetworkCookie &cookie : std::as_const(cookies)) {
            if (!first)
                result += "; ";
            first = false;
            result += cookie.toRawForm(QNetworkCookie::NameAndValueOnly);
        }
        return result;
    }
 
    case QNetworkRequest::SetCookieHeader: {
        QList<QNetworkCookie> cookies = qvariant_cast<QList<QNetworkCookie> >(value);
        if (cookies.isEmpty() && value.userType() == qMetaTypeId<QNetworkCookie>())
            cookies << qvariant_cast<QNetworkCookie>(value);
 
        QByteArray result;
        bool first = true;
        for (const QNetworkCookie &cookie : std::as_const(cookies)) {
            if (!first)
                result += ", ";
            first = false;
            result += cookie.toRawForm(QNetworkCookie::Full);
        }
        return result;
    }
    }
 
    return QByteArray();
}
 
static int parseHeaderName(const QByteArray &headerName)
{
    if (headerName.isEmpty())
        return -1;
 
    auto is = [&](const char *what) {
        return qstrnicmp(headerName.data(), headerName.size(), what) == 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(const QByteArray &raw)
{
    QDateTime dt = QNetworkHeadersPrivate::fromHttpDate(raw);
    if (dt.isValid())
        return dt;
    return QVariant();          // transform an invalid QDateTime into a null QVariant
}
 
static QVariant parseCookieHeader(const QByteArray &raw)
{
    QList<QNetworkCookie> result;
    const QList<QByteArray> cookieList = raw.split(';');
    for (const QByteArray &cookie : cookieList) {
        QList<QNetworkCookie> parsed = QNetworkCookie::parseCookies(cookie.trimmed());
        if (parsed.size() != 1)
            return QVariant();  // invalid Cookie: header
 
        result += parsed;
    }
 
    return QVariant::fromValue(result);
}
 
static QVariant parseETag(const QByteArray &raw)
{
    const QByteArray trimmed = raw.trimmed();
    if (!trimmed.startsWith('"') && !trimmed.startsWith(R"(W/")"))
        return QVariant();
 
    if (!trimmed.endsWith('"'))
        return QVariant();
 
    return QString::fromLatin1(trimmed);
}
 
static QVariant parseIfMatch(const QByteArray &raw)
{
    const QByteArray trimmedRaw = raw.trimmed();
    if (trimmedRaw == "*")
        return QStringList(QStringLiteral("*"));
 
    QStringList tags;
    const QList<QByteArray> split = trimmedRaw.split(',');
    for (const QByteArray &element : split) {
        const QByteArray trimmed = element.trimmed();
        if (!trimmed.startsWith('"'))
            continue;
 
        if (!trimmed.endsWith('"'))
            continue;
 
        tags += QString::fromLatin1(trimmed);
    }
    return tags;
}
 
static QVariant parseIfNoneMatch(const QByteArray &raw)
{
    const QByteArray trimmedRaw = raw.trimmed();
    if (trimmedRaw == "*")
        return QStringList(QStringLiteral("*"));
 
    QStringList tags;
    const QList<QByteArray> split = trimmedRaw.split(',');
    for (const QByteArray &element : split) {
        const QByteArray trimmed = element.trimmed();
        if (!trimmed.startsWith('"') && !trimmed.startsWith(R"(W/")"))
            continue;
 
        if (!trimmed.endsWith('"'))
            continue;
 
        tags += QString::fromLatin1(trimmed);
    }
    return tags;
}
 
 
static QVariant parseHeaderValue(QNetworkRequest::KnownHeaders header, const QByteArray &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 = 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 parseCookieHeader(value);
 
    case QNetworkRequest::SetCookieHeader:
        return QVariant::fromValue(QNetworkCookie::parseCookies(value));
 
    default:
        Q_ASSERT(0);
    }
    return QVariant();
}
 
QNetworkHeadersPrivate::RawHeadersList::ConstIterator
QNetworkHeadersPrivate::findRawHeader(const QByteArray &key) const
{
    RawHeadersList::ConstIterator it = rawHeaders.constBegin();
    RawHeadersList::ConstIterator end = rawHeaders.constEnd();
    for ( ; it != end; ++it)
        if (it->first.compare(key, Qt::CaseInsensitive) == 0)
            return it;
 
    return end;                 // not found
}
 
QNetworkHeadersPrivate::RawHeadersList QNetworkHeadersPrivate::allRawHeaders() const
{
    return rawHeaders;
}
 
QList<QByteArray> QNetworkHeadersPrivate::rawHeadersKeys() const
{
    QList<QByteArray> result;
    result.reserve(rawHeaders.size());
    RawHeadersList::ConstIterator it = rawHeaders.constBegin(),
                                 end = rawHeaders.constEnd();
    for ( ; it != end; ++it)
        result << it->first;
 
    return result;
}
 
void QNetworkHeadersPrivate::setRawHeader(const QByteArray &key, const QByteArray &value)
{
    if (key.isEmpty())
        // refuse to accept an empty raw header
        return;
 
    setRawHeaderInternal(key, value);
    parseAndSetHeader(key, value);
}
 
void QNetworkHeadersPrivate::setAllRawHeaders(const RawHeadersList &list)
{
    cookedHeaders.clear();
    rawHeaders = list;
 
    RawHeadersList::ConstIterator it = rawHeaders.constBegin();
    RawHeadersList::ConstIterator end = rawHeaders.constEnd();
    for ( ; it != end; ++it)
        parseAndSetHeader(it->first, it->second);
}
 
void QNetworkHeadersPrivate::setCookedHeader(QNetworkRequest::KnownHeaders header,
                                             const QVariant &value)
{
    QByteArray name = headerName(header);
    if (name.isEmpty()) {
        // headerName verifies that \a header is a known value
        qWarning("QNetworkRequest::setHeader: invalid header value KnownHeader(%d) received", header);
        return;
    }
 
    if (value.isNull()) {
        setRawHeaderInternal(name, QByteArray());
        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(), name.constData());
            return;
        }
 
        setRawHeaderInternal(name, rawValue);
        cookedHeaders.insert(header, value);
    }
}
 
void QNetworkHeadersPrivate::setRawHeaderInternal(const QByteArray &key, const QByteArray &value)
{
    auto firstEqualsKey = [&key](const RawHeaderPair &header) {
        return header.first.compare(key, Qt::CaseInsensitive) == 0;
    };
    rawHeaders.removeIf(firstEqualsKey);
 
    if (value.isNull())
        return;                 // only wanted to erase key
 
    RawHeaderPair pair;
    pair.first = key;
    pair.second = value;
    rawHeaders.append(pair);
}
 
void QNetworkHeadersPrivate::parseAndSetHeader(const QByteArray &key, const QByteArray &value)
{
    // is it a known header?
    const int parsedKeyAsInt = parseHeaderName(key);
    if (parsedKeyAsInt != -1) {
        const QNetworkRequest::KnownHeaders parsedKey
                = static_cast<QNetworkRequest::KnownHeaders>(parsedKeyAsInt);
        if (value.isNull()) {
            cookedHeaders.remove(parsedKey);
        } else if (parsedKey == QNetworkRequest::ContentLengthHeader
                 && cookedHeaders.contains(QNetworkRequest::ContentLengthHeader)) {
            // Only set the cooked header "Content-Length" once.
            // See bug QTBUG-15311
        } else {
            cookedHeaders.insert(parsedKey, parseHeaderValue(parsedKey, 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(const QByteArray &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();
}
 
QT_END_NAMESPACE