// Copyright (C) 2016 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

// Qt-Security score:critical reason:data-parser

#include "qnetworkcookie.h"

#include "qnetworkcookie_p.h"

#include "qnetworkreply.h"

#include "QtCore/qbytearray.h"

#include "QtCore/qdatetime.h"

#include "QtCore/qdebug.h"

#include "QtCore/qlist.h"

#include "QtCore/qlocale.h"

#include <QtCore/qregularexpression.h>

#include "QtCore/qstring.h"

#include "QtCore/qstringlist.h"

#include "QtCore/qtimezone.h"

#include "QtCore/qurl.h"

#include "QtNetwork/qhostaddress.h"

#include "private/qobject_p.h"

#include <utility>

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

QT_IMPL_METATYPE_EXTERN(QNetworkCookie)

/*!

    \class QNetworkCookie

    \since 4.4

    \ingroup shared

    \inmodule QtNetwork

    \brief The QNetworkCookie class holds one network cookie.

    Cookies are small bits of information that stateless protocols

    like HTTP use to maintain some persistent information across

    requests.

    A cookie is set by a remote server when it replies to a request

    and it expects the same cookie to be sent back when further

    requests are sent.

    QNetworkCookie holds one such cookie as received from the

    network. A cookie has a name and a value, but those are opaque to

    the application (that is, the information stored in them has no

    meaning to the application). A cookie has an associated path name

    and domain, which indicate when the cookie should be sent again to

    the server.

    A cookie can also have an expiration date, indicating its

    validity. If the expiration date is not present, the cookie is

    considered a "session cookie" and should be discarded when the

    application exits (or when its concept of session is over).

    QNetworkCookie provides a way of parsing a cookie from the HTTP

    header format using the QNetworkCookie::parseCookies()

    function. However, when received in a QNetworkReply, the cookie is

    already parsed.

    This class implements cookies as described by the

    \l{Netscape Cookie Specification}{initial cookie specification by

    Netscape}, which is somewhat similar to the \l{http://www.rfc-editor.org/rfc/rfc2109.txt}{RFC 2109} specification,

    plus the \l{Mitigating Cross-site Scripting With HTTP-only Cookies}

    {"HttpOnly" extension}. The more recent \l{http://www.rfc-editor.org/rfc/rfc2965.txt}{RFC 2965} specification

    (which uses the Set-Cookie2 header) is not supported.

    \sa QNetworkCookieJar, QNetworkRequest, QNetworkReply

*/

/*!

    Create a new QNetworkCookie object, initializing the cookie name

    to \a name and its value to \a value.

    A cookie is only valid if it has a name. However, the value is

    opaque to the application and being empty may have significance to

    the remote server.

*/

QNetworkCookie::QNetworkCookie(const QByteArray &name, const QByteArray &value)

    : d(new QNetworkCookiePrivate)

{

    qRegisterMetaType<QNetworkCookie>();

    qRegisterMetaType<QList<QNetworkCookie> >();

    d->name = name;

    d->value = value;

}

/*!

    Creates a new QNetworkCookie object by copying the contents of \a

    other.

*/

QNetworkCookie::QNetworkCookie(const QNetworkCookie &other)

    : d(other.d)

{

}

/*!

    Destroys this QNetworkCookie object.

*/

QNetworkCookie::~QNetworkCookie()

{

    // QSharedDataPointer auto deletes

    d = nullptr;

}

/*!

    Copies the contents of the QNetworkCookie object \a other to this

    object.

*/

QNetworkCookie &QNetworkCookie::operator=(const QNetworkCookie &other)

{

    d = other.d;

    return *this;

}

/*!

    \fn void QNetworkCookie::swap(QNetworkCookie &other)

    \since 5.0

    \memberswap{cookie}

*/

/*!

    \fn bool QNetworkCookie::operator!=(const QNetworkCookie &other) const

    Returns \c true if this cookie is not equal to \a other.

    \sa operator==()

*/

/*!

    \since 5.0

    Returns \c true if this cookie is equal to \a other. This function

    only returns \c true if all fields of the cookie are the same.

    However, in some contexts, two cookies of the same name could be

    considered equal.

    \sa operator!=(), hasSameIdentifier()

*/

bool QNetworkCookie::operator==(const QNetworkCookie &other) const

{

    if (d == other.d)

        return true;

    return d->name == other.d->name &&

        d->value == other.d->value &&

        d->expirationDate.toUTC() == other.d->expirationDate.toUTC() &&

        d->domain == other.d->domain &&

        d->path == other.d->path &&

        d->secure == other.d->secure &&

        d->comment == other.d->comment &&

        d->sameSite == other.d->sameSite;

}

/*!

    Returns \c true if this cookie has the same identifier tuple as \a other.

    The identifier tuple is composed of the name, domain and path.

    \sa operator==()

*/

bool QNetworkCookie::hasSameIdentifier(const QNetworkCookie &other) const

{

    return d->name == other.d->name && d->domain == other.d->domain && d->path == other.d->path;

}

/*!

    Returns \c true if the "secure" option was specified in the cookie

    string, false otherwise.

    Secure cookies may contain private information and should not be

    resent over unencrypted connections.

    \sa setSecure()

*/

bool QNetworkCookie::isSecure() const

{

    return d->secure;

}

/*!

    Sets the secure flag of this cookie to \a enable.

    Secure cookies may contain private information and should not be

    resent over unencrypted connections.

    \sa isSecure()

*/

void QNetworkCookie::setSecure(bool enable)

{

    d->secure = enable;

}

/*!

    Returns the "SameSite" option if specified in the cookie

    string, \c SameSite::Default if not present.

    \since 6.1

    \sa setSameSitePolicy()

*/

QNetworkCookie::SameSite QNetworkCookie::sameSitePolicy() const

{

    return d->sameSite;

}

/*!

    Sets the "SameSite" option of this cookie to \a sameSite.

    \since 6.1

    \sa sameSitePolicy()

*/

void QNetworkCookie::setSameSitePolicy(QNetworkCookie::SameSite sameSite)

{

    d->sameSite = sameSite;

}

/*!

    \since 4.5

    Returns \c true if the "HttpOnly" flag is enabled for this cookie.

    A cookie that is "HttpOnly" is only set and retrieved by the

    network requests and replies; i.e., the HTTP protocol. It is not

    accessible from scripts running on browsers.

    \sa isSecure()

*/

bool QNetworkCookie::isHttpOnly() const

{

    return d->httpOnly;

}

/*!

    \since 4.5

    Sets this cookie's "HttpOnly" flag to \a enable.

*/

void QNetworkCookie::setHttpOnly(bool enable)

{

    d->httpOnly = enable;

}

/*!

    Returns \c true if this cookie is a session cookie. A session cookie

    is a cookie which has no expiration date, which means it should be

    discarded when the application's concept of session is over

    (usually, when the application exits).

    \sa expirationDate(), setExpirationDate()

*/

bool QNetworkCookie::isSessionCookie() const

{

    return !d->expirationDate.isValid();

}

/*!

    Returns the expiration date for this cookie. If this cookie is a

    session cookie, the QDateTime returned will not be valid. If the

    date is in the past, this cookie has already expired and should

    not be sent again back to a remote server.

    The expiration date corresponds to the parameters of the "expires"

    entry in the cookie string.

    \sa isSessionCookie(), setExpirationDate()

*/

QDateTime QNetworkCookie::expirationDate() const

{

    return d->expirationDate;

}

/*!

    Sets the expiration date of this cookie to \a date. Setting an

    invalid expiration date to this cookie will mean it's a session

    cookie.

    \sa isSessionCookie(), expirationDate()

*/

void QNetworkCookie::setExpirationDate(const QDateTime &date)

{

    d->expirationDate = date;

}

/*!

    Returns the domain this cookie is associated with. This

    corresponds to the "domain" field of the cookie string.

    Note that the domain here may start with a dot, which is not a

    valid hostname. However, it means this cookie matches all

    hostnames ending with that domain name.

    \sa setDomain()

*/

QString QNetworkCookie::domain() const

{

    return d->domain;

}

/*!

    Sets the domain associated with this cookie to be \a domain.

    \sa domain()

*/

void QNetworkCookie::setDomain(const QString &domain)

{

    d->domain = domain;

}

/*!

    Returns the path associated with this cookie. This corresponds to

    the "path" field of the cookie string.

    \sa setPath()

*/

QString QNetworkCookie::path() const

{

    return d->path;

}

/*!

    Sets the path associated with this cookie to be \a path.

    \sa path()

*/

void QNetworkCookie::setPath(const QString &path)

{

    d->path = path;

}

/*!

    Returns the name of this cookie. The only mandatory field of a

    cookie is its name, without which it is not considered valid.

    \sa setName(), value()

*/

QByteArray QNetworkCookie::name() const

{

    return d->name;

}

/*!

    Sets the name of this cookie to be \a cookieName. Note that

    setting a cookie name to an empty QByteArray will make this cookie

    invalid.

    \sa name(), value()

*/

void QNetworkCookie::setName(const QByteArray &cookieName)

{

    d->name = cookieName;

}

/*!

    Returns this cookies value, as specified in the cookie

    string. Note that a cookie is still valid if its value is empty.

    Cookie name-value pairs are considered opaque to the application:

    that is, their values don't mean anything.

    \sa setValue(), name()

*/

QByteArray QNetworkCookie::value() const

{

    return d->value;

}

/*!

    Sets the value of this cookie to be \a value.

    \sa value(), name()

*/

void QNetworkCookie::setValue(const QByteArray &value)

{

    d->value = value;

}

// ### move this to qnetworkcookie_p.h and share with qnetworkaccesshttpbackend

static std::pair<QByteArray, QByteArray> nextField(QByteArrayView text, int &position, bool isNameValue)

{

    // format is one of:

    //    (1)  token

    //    (2)  token = token

    //    (3)  token = quoted-string

    const int length = text.size();

    position = nextNonWhitespace(text, position);

    int semiColonPosition = text.indexOf(';', position);

    if (semiColonPosition < 0)

        semiColonPosition = length; //no ';' means take everything to end of string

    int equalsPosition = text.indexOf('=', position);

    if (equalsPosition < 0 || equalsPosition > semiColonPosition) {

        if (isNameValue)

            return std::pair(QByteArray(), QByteArray()); //'=' is required for name-value-pair (RFC6265 section 5.2, rule 2)

        equalsPosition = semiColonPosition; //no '=' means there is an attribute-name but no attribute-value

    }

    QByteArray first = text.mid(position, equalsPosition - position).trimmed().toByteArray();

    QByteArray second;

    int secondLength = semiColonPosition - equalsPosition - 1;

    if (secondLength > 0)

        second = text.mid(equalsPosition + 1, secondLength).trimmed().toByteArray();

    position = semiColonPosition;

    return std::pair(first, second);

}

/*!

    \enum QNetworkCookie::RawForm

    This enum is used with the toRawForm() function to declare which

    form of a cookie shall be returned.

    \value NameAndValueOnly     makes toRawForm() return only the

        "NAME=VALUE" part of the cookie, as suitable for sending back

        to a server in a client request's "Cookie:" header. Multiple

        cookies are separated by a semi-colon in the "Cookie:" header

        field.

    \value Full                 makes toRawForm() return the full

        cookie contents, as suitable for sending to a client in a

        server's "Set-Cookie:" header.

    Note that only the Full form of the cookie can be parsed back into

    its original contents.

    \sa toRawForm(), parseCookies()

*/

/*!

    \enum QNetworkCookie::SameSite

    \since 6.1

    \value Default  SameSite is not set. Can be interpreted as None or Lax by the browser.

    \value None     Cookies can be sent in all contexts. This used to be default, but

        recent browsers made Lax default, and will now require the cookie to be both secure and to set SameSite=None.

    \value Lax      Cookies are sent on first party requests and GET requests initiated by third party website.

        This is the default in modern browsers (since mid 2020).

    \value Strict   Cookies will only be sent in a first-party context.

    \sa setSameSitePolicy(), sameSitePolicy()

*/

namespace {

constexpr QByteArrayView sameSiteNone() noexcept { return "None"; }

constexpr QByteArrayView sameSiteLax() noexcept { return "Lax"; }

constexpr QByteArrayView sameSiteStrict() noexcept { return "Strict"; }

QByteArrayView sameSiteToRawString(QNetworkCookie::SameSite samesite) noexcept

{

    switch (samesite) {

    case QNetworkCookie::SameSite::None:

        return sameSiteNone();

    case QNetworkCookie::SameSite::Lax:

        return sameSiteLax();

    case QNetworkCookie::SameSite::Strict:

        return sameSiteStrict();

    case QNetworkCookie::SameSite::Default:

        break;

    }

    return QByteArrayView();

}

QNetworkCookie::SameSite sameSiteFromRawString(QByteArrayView str) noexcept

{

    if (str.compare(sameSiteNone(), Qt::CaseInsensitive) == 0)

        return QNetworkCookie::SameSite::None;

    if (str.compare(sameSiteLax(), Qt::CaseInsensitive) == 0)

        return QNetworkCookie::SameSite::Lax;

    if (str.compare(sameSiteStrict(), Qt::CaseInsensitive) == 0)

        return QNetworkCookie::SameSite::Strict;

    return QNetworkCookie::SameSite::Default;

}

} // namespace

/*!

    Returns the raw form of this QNetworkCookie. The QByteArray

    returned by this function is suitable for an HTTP header, either

    in a server response (the Set-Cookie header) or the client request

    (the Cookie header). You can choose from one of two formats, using

    \a form.

    \sa parseCookies()

*/

QByteArray QNetworkCookie::toRawForm(RawForm form) const

{

    QByteArray result;

    if (d->name.isEmpty())

        return result;          // not a valid cookie

    result = d->name;

    result += '=';

    result += d->value;

    if (form == Full) {

        // same as above, but encoding everything back

        if (isSecure())

            result += "; secure";

        if (isHttpOnly())

            result += "; HttpOnly";

        if (d->sameSite != SameSite::Default) {

            result += "; SameSite=";

            result += sameSiteToRawString(d->sameSite);

        }

        if (!isSessionCookie()) {

            result += "; expires=";

            result += QLocale::c().toString(d->expirationDate.toUTC(),

                                            "ddd, dd-MMM-yyyy hh:mm:ss 'GMT"_L1).toLatin1();

        }

        if (!d->domain.isEmpty()) {

            result += "; domain=";

            if (d->domain.startsWith(u'.')) {

                result += '.';

                result += QUrl::toAce(d->domain.mid(1));

            } else {

                QHostAddress hostAddr(d->domain);

                if (hostAddr.protocol() == QAbstractSocket::IPv6Protocol) {

                    result += '[';

                    result += d->domain.toUtf8();

                    result += ']';

                } else {

                    result += QUrl::toAce(d->domain);

                }

            }

        }

        if (!d->path.isEmpty()) {

            result += "; path=";

            result += d->path.toUtf8();

        }

    }

    return result;

}

static const char zones[] =

    "pst\0" // -8

    "pdt\0"

    "mst\0" // -7

    "mdt\0"

    "cst\0" // -6

    "cdt\0"

    "est\0" // -5

    "edt\0"

    "ast\0" // -4

    "nst\0" // -3

    "gmt\0" // 0

    "utc\0"

    "bst\0"

    "met\0" // 1

    "eet\0" // 2

    "jst\0" // 9

    "\0";

static const int zoneOffsets[] = {-8, -8, -7, -7, -6, -6, -5, -5, -4, -3, 0, 0, 0, 1, 2, 9 };

static const char months[] =

    "jan\0"

    "feb\0"

    "mar\0"

    "apr\0"

    "may\0"

    "jun\0"

    "jul\0"

    "aug\0"

    "sep\0"

    "oct\0"

    "nov\0"

    "dec\0"

    "\0";

static inline bool isNumber(char s)

{ return s >= '0' && s <= '9'; }

static inline bool isTerminator(char c)

{ return c == '\n' || c == '\r'; }

static inline bool isValueSeparator(char c)

{ return isTerminator(c) || c == ';'; }

static inline bool isWhitespace(char c)

{ return c == ' '  || c == '\t'; }

static bool checkStaticArray(int &val, QByteArrayView dateString, int at, const char *array, int size)

{

    if (dateString[at] < 'a' || dateString[at] > 'z')

        return false;

    if (val == -1 && dateString.size() >= at + 3) {

        int j = 0;

        int i = 0;

        while (i <= size) {

            const char *str = array + i;

            if (str[0] == dateString[at]

                && str[1] == dateString[at + 1]

                && str[2] == dateString[at + 2]) {

                val = j;

                return true;

            }

            i += int(strlen(str)) + 1;

            ++j;

        }

    }

    return false;

}

//#define PARSEDATESTRINGDEBUG

#define ADAY   1

#define AMONTH 2

#define AYEAR  4

/*

    Parse all the date formats that Firefox can.

    The official format is:

    expires=ddd(d)?, dd-MMM-yyyy hh:mm:ss GMT

    But browsers have been supporting a very wide range of date

    strings. To work on many sites we need to support more then

    just the official date format.

    For reference see Firefox's PR_ParseTimeStringToExplodedTime in

    prtime.c. The Firefox date parser is coded in a very complex way

    and is slightly over ~700 lines long.  While this implementation

    will be slightly slower for the non standard dates it is smaller,

    more readable, and maintainable.

    Or in their own words:

        "} // else what the hell is this."

*/

static QDateTime parseDateString(QByteArrayView dateString)

{

    QTime time;

    // placeholders for values when we are not sure it is a year, month or day

    int unknown[3] = {-1, -1, -1};

    int month = -1;

    int day = -1;

    int year = -1;

    int zoneOffset = -1;

    // hour:minute:second.ms pm

    static const QRegularExpression timeRx(

            u"(\\d\\d?):(\\d\\d?)(?::(\\d\\d?)(?:\\.(\\d{1,3}))?)?(?:\\s*(am|pm))?"_s);

    int at = 0;

    while (at < dateString.size()) {

#ifdef PARSEDATESTRINGDEBUG

        qDebug() << dateString.mid(at);

#endif

        bool isNum = isNumber(dateString[at]);

        // Month

        if (!isNum

            && checkStaticArray(month, dateString, at, months, sizeof(months)- 1)) {

            ++month;

#ifdef PARSEDATESTRINGDEBUG

            qDebug() << "Month:" << month;

#endif

            at += 3;

            continue;

        }

        // Zone

        if (!isNum

            && zoneOffset == -1

            && checkStaticArray(zoneOffset, dateString, at, zones, sizeof(zones)- 1)) {

            int sign = (at >= 0 && dateString[at - 1] == '-') ? -1 : 1;

            zoneOffset = sign * zoneOffsets[zoneOffset] * 60 * 60;

#ifdef PARSEDATESTRINGDEBUG

            qDebug() << "Zone:" << month;

#endif

            at += 3;

            continue;

        }

        // Zone offset

        if (!isNum

            && (zoneOffset == -1 || zoneOffset == 0) // Can only go after gmt

            && (dateString[at] == '+' || dateString[at] == '-')

            && (at == 0

                || isWhitespace(dateString[at - 1])

                || dateString[at - 1] == ','

                || (at >= 3

                    && (dateString[at - 3] == 'g')

                    && (dateString[at - 2] == 'm')

                    && (dateString[at - 1] == 't')))) {

            int end = 1;

            while (end < 5 && dateString.size() > at+end

                   && dateString[at + end] >= '0' && dateString[at + end] <= '9')

                ++end;

            int minutes = 0;

            int hours = 0;

            switch (end - 1) {

            case 4:

                minutes = dateString.mid(at + 3, 2).toInt();

                Q_FALLTHROUGH();

            case 2:

                hours = dateString.mid(at + 1, 2).toInt();

                break;

            case 1:

                hours = dateString.mid(at + 1, 1).toInt();

                break;

            default:

                at += end;

                continue;

            }

            if (end != 1) {

                int sign = dateString[at] == '-' ? -1 : 1;

                zoneOffset = sign * ((minutes * 60) + (hours * 60 * 60));

#ifdef PARSEDATESTRINGDEBUG

                qDebug() << "Zone offset:" << zoneOffset << hours << minutes;

#endif

                at += end;

                continue;

            }

        }

        // Time

        if (isNum && time.isNull()

            && dateString.size() >= at + 3

            && (dateString[at + 2] == ':' || dateString[at + 1] == ':')) {

            // While the date can be found all over the string the format

            // for the time is set and a nice regexp can be used.

            // This string needs to stay for as long as the QRegularExpressionMatch is used,

            // or else we get use-after-free issues:

            QString dateToString = QString::fromLatin1(dateString);

            if (auto match = timeRx.match(dateToString, at); match.hasMatch()) {

                int h = match.capturedView(1).toInt();

                int m = match.capturedView(2).toInt();

                int s = match.capturedView(3).toInt();

                int ms = match.capturedView(4).toInt();

                QStringView ampm = match.capturedView(5);

                if (h < 12 && !ampm.isEmpty())

                    if (ampm == "pm"_L1)

                        h += 12;

                time = QTime(h, m, s, ms);

#ifdef PARSEDATESTRINGDEBUG

                qDebug() << "Time:" << match.capturedTexts() << match.capturedLength();

#endif

                at += match.capturedLength();

                continue;

            }

        }

        // 4 digit Year

        if (isNum

            && year == -1

            && dateString.size() > at + 3) {

            if (isNumber(dateString[at + 1])

                && isNumber(dateString[at + 2])

                && isNumber(dateString[at + 3])) {

                year = dateString.mid(at, 4).toInt();

                at += 4;

#ifdef PARSEDATESTRINGDEBUG

                qDebug() << "Year:" << year;

#endif

                continue;

            }

        }

        // a one or two digit number

        // Could be month, day or year

        if (isNum) {

            int length = 1;

            if (dateString.size() > at + 1

                && isNumber(dateString[at + 1]))

                ++length;

            int x = dateString.mid(at, length).toInt();

            if (year == -1 && (x > 31 || x == 0)) {

                year = x;

            } else {

                if (unknown[0] == -1) unknown[0] = x;

                else if (unknown[1] == -1) unknown[1] = x;

                else if (unknown[2] == -1) unknown[2] = x;

            }

            at += length;

#ifdef PARSEDATESTRINGDEBUG

            qDebug() << "Saving" << x;

#endif

            continue;

        }

        // Unknown character, typically a weekday such as 'Mon'

        ++at;

    }

    // Once we are done parsing the string take the digits in unknown

    // and determine which is the unknown year/month/day

    int couldBe[3] = { 0, 0, 0 };

    int unknownCount = 3;

    for (int i = 0; i < unknownCount; ++i) {

        if (unknown[i] == -1) {

            couldBe[i] = ADAY | AYEAR | AMONTH;

            unknownCount = i;

            continue;

        }

        if (unknown[i] >= 1)

            couldBe[i] = ADAY;

        if (month == -1 && unknown[i] >= 1 && unknown[i] <= 12)

            couldBe[i] |= AMONTH;

        if (year == -1)

            couldBe[i] |= AYEAR;

    }

    // For any possible day make sure one of the values that could be a month

    // can contain that day.

    // For any possible month make sure one of the values that can be a

    // day that month can have.

    // Example: 31 11 06

    // 31 can't be a day because 11 and 6 don't have 31 days

    for (int i = 0; i < unknownCount; ++i) {

        int currentValue = unknown[i];

        bool findMatchingMonth = couldBe[i] & ADAY && currentValue >= 29;

        bool findMatchingDay = couldBe[i] & AMONTH;

        if (!findMatchingMonth || !findMatchingDay)

            continue;

        for (int j = 0; j < 3; ++j) {

            if (j == i)

                continue;

            for (int k = 0; k < 2; ++k) {

                if (k == 0 && !(findMatchingMonth && (couldBe[j] & AMONTH)))

                    continue;

                else if (k == 1 && !(findMatchingDay && (couldBe[j] & ADAY)))

                    continue;

                int m = currentValue;

                int d = unknown[j];

                if (k == 0)

                    qSwap(m, d);

                if (m == -1) m = month;

                bool found = true;

                switch(m) {

                    case 2:

                        // When we get 29 and the year ends up having only 28

                        // See date.isValid below

                        // Example: 29 23 Feb

                        if (d <= 29)

                            found = false;

                        break;

                    case 4: case 6: case 9: case 11:

                        if (d <= 30)

                            found = false;

                        break;

                    default:

                        if (d > 0 && d <= 31)

                            found = false;

                }

                if (k == 0) findMatchingMonth = found;

                else if (k == 1) findMatchingDay = found;

            }

        }

        if (findMatchingMonth)

            couldBe[i] &= ~ADAY;

        if (findMatchingDay)

            couldBe[i] &= ~AMONTH;

    }

    // First set the year/month/day that have been deduced

    // and reduce the set as we go along to deduce more

    for (int i = 0; i < unknownCount; ++i) {

        int unset = 0;

        for (int j = 0; j < 3; ++j) {

            if (couldBe[j] == ADAY && day == -1) {

                day = unknown[j];

                unset |= ADAY;

            } else if (couldBe[j] == AMONTH && month == -1) {

                month = unknown[j];

                unset |= AMONTH;

            } else if (couldBe[j] == AYEAR && year == -1) {

                year = unknown[j];

                unset |= AYEAR;

            } else {

                // common case

                break;

            }

            couldBe[j] &= ~unset;

        }

    }

    // Now fallback to a standardized order to fill in the rest with

    for (int i = 0; i < unknownCount; ++i) {

        if (couldBe[i] & AMONTH && month == -1) month = unknown[i];

        else if (couldBe[i] & ADAY && day == -1) day = unknown[i];

        else if (couldBe[i] & AYEAR && year == -1) year = unknown[i];

    }

#ifdef PARSEDATESTRINGDEBUG

        qDebug() << "Final set" << year << month << day;

#endif

    if (year == -1 || month == -1 || day == -1) {

#ifdef PARSEDATESTRINGDEBUG

        qDebug() << "Parser failure" << year << month << day;

#endif

        return QDateTime();

    }

    // Y2k behavior

    int y2k = 0;

    if (year < 70)

        y2k = 2000;

    else if (year < 100)

        y2k = 1900;

    QDate date(year + y2k, month, day);

    // When we were given a bad cookie that when parsed

    // set the day to 29 and the year to one that doesn't

    // have the 29th of Feb rather then adding the extra

    // complicated checking earlier just swap here.

    // Example: 29 23 Feb

    if (!date.isValid())

        date = QDate(day + y2k, month, year);

    QDateTime dateTime(date, time, QTimeZone::UTC);

    if (zoneOffset != -1)

        dateTime = dateTime.addSecs(zoneOffset);

    if (!dateTime.isValid())

        return QDateTime();

    return dateTime;

}

/*!

    Parses the cookie string \a cookieString as received from a server

    response in the "Set-Cookie:" header. If there's a parsing error,

    this function returns an empty list.

    Since the HTTP header can set more than one cookie at the same

    time, this function returns a QList<QNetworkCookie>, one for each

    cookie that is parsed.

    \sa toRawForm()

    \note In Qt versions prior to 6.7, this function took QByteArray only.

*/

QList<QNetworkCookie> QNetworkCookie::parseCookies(QByteArrayView cookieString)

{

    // cookieString can be a number of set-cookie header strings joined together

    // by \n, parse each line separately.

    QList<QNetworkCookie> cookies;

    for (auto s : QLatin1StringView(cookieString).tokenize('\n'_L1))

        cookies += QNetworkCookiePrivate::parseSetCookieHeaderLine(s);

    return cookies;