// 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:network-protocol

#include "access/http2/http2protocol_p.h"

#include "access/qhttp2connection_p.h"

#include "qhttpnetworkconnection_p.h"

#include "qhttp2protocolhandler_p.h"

#include "http2/http2frames_p.h"

#include <private/qnoncontiguousbytedevice_p.h>

#include <private/qsocketabstraction_p.h>

#include <QtNetwork/qabstractsocket.h>

#include <QtCore/qloggingcategory.h>

#include <QtCore/qendian.h>

#include <QtCore/qdebug.h>

#include <QtCore/qlist.h>

#include <QtCore/qnumeric.h>

#include <QtCore/qurl.h>

#include <qhttp2configuration.h>

#ifndef QT_NO_NETWORKPROXY

#  include <QtNetwork/qnetworkproxy.h>

#endif

#include <qcoreapplication.h>

#include <algorithm>

#include <vector>

#include <optional>

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

namespace

{

HPack::HttpHeader build_headers(const QHttpNetworkRequest &request, quint32 maxHeaderListSize,

                                bool useProxy)

{

    using namespace HPack;

    HttpHeader header;

    header.reserve(300);

    // 1. Before anything - mandatory fields, if they do not fit into maxHeaderList -

    // then stop immediately with error.

    const auto auth = request.url().authority(QUrl::FullyEncoded | QUrl::RemoveUserInfo).toLatin1();

    header.emplace_back(":authority", auth);

    header.emplace_back(":method", request.methodName());

    header.emplace_back(":path", request.uri(useProxy));

    header.emplace_back(":scheme", request.url().scheme().toLatin1());

    HeaderSize size = header_size(header);

    if (!size.first) // Ooops!

        return HttpHeader();

    if (size.second > maxHeaderListSize)

        return HttpHeader(); // Bad, we cannot send this request ...

    const QHttpHeaders requestHeader = request.header();

    using WK = QHttpHeaders::WellKnownHeader;

    for (qsizetype i = 0; i < requestHeader.size(); ++i) {

        const auto name = requestHeader.nameAt(i);

        const auto value = requestHeader.valueAt(i);

        const HeaderSize delta = entry_size(name, value);

        if (!delta.first) // Overflow???

            break;

        if (std::numeric_limits<quint32>::max() - delta.second < size.second)

            break;

        size.second += delta.second;

        if (size.second > maxHeaderListSize)

            break;

        if (name == QHttpHeaders::wellKnownHeaderName(WK::Connection)

            || name == QHttpHeaders::wellKnownHeaderName(WK::Host)

            || name == QHttpHeaders::wellKnownHeaderName(WK::KeepAlive)

            || name.compare("proxy-connection"_L1, Qt::CaseInsensitive) == 0

            || name == QHttpHeaders::wellKnownHeaderName(WK::TransferEncoding)) {

            continue; // Those headers are not valid (section 3.2.1) - from QSpdyProtocolHandler

        }

        // TODO: verify with specs, which fields are valid to send ....

        //

        // Note: RFC 7450 8.1.2 (HTTP/2) states that header field names must be lower-cased

        // prior to their encoding in HTTP/2

        header.emplace_back(QByteArray{name.data(), name.size()}.toLower(),

                            QByteArray{value.data(), value.size()});

    }

    return header;

}

QUrl urlkey_from_request(const QHttpNetworkRequest &request)

{

    QUrl url;

    url.setScheme(request.url().scheme());

    url.setAuthority(request.url().authority(QUrl::FullyEncoded | QUrl::RemoveUserInfo));

    url.setPath(QLatin1StringView(request.uri(false)));

    return url;

}

} // Unnamed namespace

// Since we anyway end up having this in every function definition:

using namespace Http2;

QHttp2ProtocolHandler::QHttp2ProtocolHandler(QHttpNetworkConnectionChannel *channel)

    : QAbstractProtocolHandler(channel)

{

    const auto h2Config = m_connection->http2Parameters();

    if (!channel->ssl

        && m_connection->connectionType() != QHttpNetworkConnection::ConnectionTypeHTTP2Direct) {

        h2Connection = QHttp2Connection::createUpgradedConnection(channel->socket, h2Config);

        // Since we upgraded there is already one stream (the request was sent as http1)

        // and we need to handle it:

        QHttp2Stream *stream = h2Connection->getStream(1);

        Q_ASSERT(stream);

        Q_ASSERT(channel->reply);

        connectStream({ channel->request, channel->reply }, stream);

    } else {

        Q_ASSERT(QSocketAbstraction::socketState(channel->socket) == QAbstractSocket::ConnectedState);

        h2Connection = QHttp2Connection::createDirectConnection(channel->socket, h2Config);

    }

    connect(h2Connection, &QHttp2Connection::receivedGOAWAY, this,

            &QHttp2ProtocolHandler::handleGOAWAY);

    connect(h2Connection, &QHttp2Connection::errorOccurred, this,

            &QHttp2ProtocolHandler::connectionError);

    connect(h2Connection, &QHttp2Connection::newIncomingStream, this,

            [this](QHttp2Stream *stream){

                // Having our peer start streams doesn't make sense. We are

                // doing regular http request-response.

                stream->sendRST_STREAM(REFUSE_STREAM);

                if (!h2Connection->isGoingAway())

                    h2Connection->close(Http2::PROTOCOL_ERROR);

            });

    connect(h2Connection, &QHttp2Connection::connectionClosed, this,

            &QHttp2ProtocolHandler::closeSession);

}

bool QHttp2ProtocolHandler::isGoingAway() const noexcept

{

    return h2Connection && h2Connection->isGoingAway();

}

void QHttp2ProtocolHandler::handleConnectionClosure()

{

    // The channel has just received RemoteHostClosedError and since it will

    // not try (for HTTP/2) to re-connect, it's time to finish all replies

    // with error.

    // Maybe we still have some data to read and can successfully finish

    // a stream/request?

    _q_receiveReply();

    h2Connection->handleConnectionClosure();

}

void QHttp2ProtocolHandler::_q_uploadDataDestroyed(QObject *uploadData)

{

    QPointer<QHttp2Stream> stream = streamIDs.take(uploadData);

    if (stream && stream->isActive())

        stream->sendRST_STREAM(CANCEL);

}

void QHttp2ProtocolHandler::_q_readyRead()

{

    _q_receiveReply();

}

void QHttp2ProtocolHandler::_q_receiveReply()

{

    // not using QObject::connect because the QHttpNetworkConnectionChannel

    // already handles the signals we care about, so we just call the slot

    // directly.

    Q_ASSERT(h2Connection);

    h2Connection->handleReadyRead();

}

bool QHttp2ProtocolHandler::sendRequest()

{

    if (isGoingAway())

        return false;

    // Process 'fake' (created by QNetworkAccessManager::connectToHostEncrypted())

    // requests first:

    auto &requests = m_channel->h2RequestsToSend;

    for (auto it = requests.begin(), endIt = requests.end(); it != endIt;) {

        const auto &pair = *it;

        if (pair.first.isPreConnect()) {

            m_connection->preConnectFinished();

            emit pair.second->finished();

            it = requests.erase(it);

            if (requests.empty()) {

                // Normally, after a connection was established and H2

                // was negotiated, we send a client preface. connectToHostEncrypted

                // though is not meant to send any data, it's just a 'preconnect'.

                // Thus we return early:

                return true;

            }

        } else {

            ++it;

        }

    }

    if (requests.empty())

        return true;

    m_channel->state = QHttpNetworkConnectionChannel::WritingState;

    // Check what was promised/pushed, maybe we do not have to send a request

    // and have a response already?

    for (auto it = requests.begin(), end = requests.end(); it != end;) {

        HttpMessagePair &httpPair = *it;

        QUrl promiseKey = urlkey_from_request(httpPair.first);

        if (h2Connection->promisedStream(promiseKey) != nullptr) {

            // There's a PUSH_PROMISE for this request, so we don't send one

            initReplyFromPushPromise(httpPair, promiseKey);

            it = requests.erase(it);

            continue;

        }

        QHttp2Stream *stream = createNewStream(httpPair);

        if (!stream) { // There was an issue creating the stream

            // Check if it was unrecoverable, ie. the reply is errored out and finished:

            if (httpPair.second->isFinished()) {

                it = requests.erase(it);

            }

            // ... either way we stop looping:

            break;

        }

        QHttpNetworkRequest &request = requestReplyPairs[stream].first;

        if (!sendHEADERS(stream, request)) {

            finishStreamWithError(stream, QNetworkReply::UnknownNetworkError,

                    "failed to send HEADERS frame(s)"_L1);

            continue;

        }

        if (request.uploadByteDevice()) {

            if (!sendDATA(stream, httpPair.second)) {

                finishStreamWithError(stream, QNetworkReply::UnknownNetworkError,

                                      "failed to send DATA frame(s)"_L1);

                continue;

            }

        }

        it = requests.erase(it);

    }

    m_channel->state = QHttpNetworkConnectionChannel::IdleState;

    return true;

}

/*!

    \internal

    This gets called during destruction of \a reply, so do not call any functions

    on \a reply. We check if there is a stream associated with the reply and,

    if there is, we remove the request-reply pair associated with this stream,

    delete the stream and return \c{true}. Otherwise nothing happens and we

    return \c{false}.

*/

bool QHttp2ProtocolHandler::tryRemoveReply(QHttpNetworkReply *reply)

{

    QHttp2Stream *stream = streamIDs.take(reply);

    if (stream) {

        stream->sendRST_STREAM(stream->isUploadingDATA() ? Http2::CANCEL : Http2::HTTP2_NO_ERROR);

        clearStreamState(stream);

        stream->deleteLater();

        return true;

    }

    return false;

}

bool QHttp2ProtocolHandler::sendHEADERS(QHttp2Stream *stream, QHttpNetworkRequest &request)

{

    using namespace HPack;

    bool useProxy = false;

#ifndef QT_NO_NETWORKPROXY

    useProxy = m_connection->d_func()->networkProxy.type() != QNetworkProxy::NoProxy;

#endif

    if (request.withCredentials()) {

        m_connection->d_func()->createAuthorization(m_socket, request);

        request.d->needResendWithCredentials = false;

    }

    const auto headers = build_headers(request, h2Connection->maxHeaderListSize(), useProxy);

    if (headers.empty()) // nothing fits into maxHeaderListSize

        return false;

    bool mustUploadData = request.uploadByteDevice();

    return stream->sendHEADERS(headers, !mustUploadData);

}

bool QHttp2ProtocolHandler::sendDATA(QHttp2Stream *stream, QHttpNetworkReply *reply)

{

    Q_ASSERT(reply);

    QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();

    Q_ASSERT(replyPrivate);

    QHttpNetworkRequest &request = replyPrivate->request;

    Q_ASSERT(request.uploadByteDevice());

    bool startedSending = stream->sendDATA(request.uploadByteDevice(), true);

    return startedSending && !stream->wasReset();

}

void QHttp2ProtocolHandler::handleHeadersReceived(const HPack::HttpHeader &headers, bool endStream)

{

    QHttp2Stream *stream = qobject_cast<QHttp2Stream *>(sender());

    Q_ASSERT(stream);

    auto &requestPair = requestReplyPairs[stream];

    auto *httpReply = requestPair.second;

    auto &httpRequest = requestPair.first;

    if (!httpReply)

        return;

    auto *httpReplyPrivate = httpReply->d_func();

    // For HTTP/1 'location' is handled (and redirect URL set) when a protocol

    // handler emits channel->allDone(). Http/2 protocol handler never emits

    // allDone, since we have many requests multiplexed in one channel at any

    // moment and we are probably not done yet. So we extract url and set it

    // here, if needed.

    int statusCode = 0;

    for (const auto &pair : headers) {

        const auto &name = pair.name;

        const auto value = QByteArrayView(pair.value);

        // TODO: part of this code copies what SPDY protocol handler does when

        // processing headers. Binary nature of HTTP/2 and SPDY saves us a lot

        // of parsing and related errors/bugs, but it would be nice to have

        // more detailed validation of headers.

        if (name == ":status") {

            bool ok = false;

            if (int status = value.toInt(&ok); ok && status >= 0 && status <= 999) {

                statusCode = status;

                httpReply->setStatusCode(statusCode);

                m_channel->lastStatus = statusCode; // Mostly useless for http/2, needed for auth

            } else {

                finishStreamWithError(stream, QNetworkReply::ProtocolInvalidOperationError,

                                      "invalid :status value"_L1);

                return;

            }

        } else if (name == "content-length") {

            bool ok = false;

            const qlonglong length = value.toLongLong(&ok);

            if (ok)

                httpReply->setContentLength(length);

        } else {

            const auto binder = name == "set-cookie" ? QByteArrayView("\n") : QByteArrayView(", ");

            httpReply->appendHeaderField(name, QByteArray(pair.value).replace('\0', binder));

        }

    }

    // Discard all informational (1xx) replies with the exception of 101.

    // Also see RFC 9110 (Chapter 15.2)

    if (statusCode == 100 || (102 <= statusCode && statusCode <= 199)) {

        httpReplyPrivate->clearHttpLayerInformation();

        return;

    }

    if (QHttpNetworkReply::isHttpRedirect(statusCode) && httpRequest.isFollowRedirects()) {

        QHttpNetworkConnectionPrivate::ParseRedirectResult

                result = QHttpNetworkConnectionPrivate::parseRedirectResponse(httpReply);

        if (result.errorCode != QNetworkReply::NoError) {

            auto errorString = m_connection->d_func()->errorDetail(result.errorCode, m_socket);

            finishStreamWithError(stream, result.errorCode, errorString);

            stream->sendRST_STREAM(INTERNAL_ERROR);

            return;

        }

        if (result.redirectUrl.isValid())

            httpReply->setRedirectUrl(result.redirectUrl);

    }

    if (httpReplyPrivate->isCompressed() && httpRequest.d->autoDecompress)

        httpReplyPrivate->removeAutoDecompressHeader();

    if (QHttpNetworkReply::isHttpRedirect(statusCode)) {

        // Note: This status code can trigger uploadByteDevice->reset() in

        // QHttpNetworkConnectionChannel::handleStatus. Alas, we have no single

        // request/reply, we multiplex several requests and thus we never simply

        // call 'handleStatus'. If we have a byte-device - we try to reset it

        // here, we don't (and can't) handle any error during reset operation.

        if (auto *byteDevice = httpRequest.uploadByteDevice()) {

            byteDevice->reset();

            httpReplyPrivate->totallyUploadedData = 0;

        }

    }

    QMetaObject::invokeMethod(httpReply, &QHttpNetworkReply::headerChanged, Qt::QueuedConnection);

    if (endStream)

        finishStream(stream, Qt::QueuedConnection);

}

void QHttp2ProtocolHandler::handleDataReceived(const QByteArray &data, bool endStream)

{

    QHttp2Stream *stream = qobject_cast<QHttp2Stream *>(sender());

    auto &httpPair = requestReplyPairs[stream];

    auto *httpReply = httpPair.second;

    if (!httpReply)

        return;

    Q_ASSERT(!stream->isPromisedStream());

    if (!data.isEmpty() && !httpPair.first.d->needResendWithCredentials) {

        auto *replyPrivate = httpReply->d_func();

        replyPrivate->totalProgress += data.size();

        replyPrivate->responseData.append(data);

        if (replyPrivate->shouldEmitSignals()) {

            QMetaObject::invokeMethod(httpReply, &QHttpNetworkReply::readyRead,

                                      Qt::QueuedConnection);

            QMetaObject::invokeMethod(httpReply, &QHttpNetworkReply::dataReadProgress,

                                      Qt::QueuedConnection, replyPrivate->totalProgress,

                                      replyPrivate->bodyLength);

        }

    }

    stream->clearDownloadBuffer();

    if (endStream)

        finishStream(stream, Qt::QueuedConnection);

}

// After calling this function, either the request will be re-sent or

// the reply will be finishedWithError! Do not emit finished() or similar on the

// reply after this!

void QHttp2ProtocolHandler::handleAuthorization(QHttp2Stream *stream)

{

    auto &requestPair = requestReplyPairs[stream];

    auto *httpReply = requestPair.second;

    auto *httpReplyPrivate = httpReply->d_func();

    auto &httpRequest = requestPair.first;

    Q_ASSERT(httpReply && (httpReply->statusCode() == 401 || httpReply->statusCode() == 407));

    const auto handleAuth = [&, this](QByteArrayView authField, bool isProxy) -> bool {

        Q_ASSERT(httpReply);

        const QByteArrayView auth = authField.trimmed();

        if (auth.startsWith("Negotiate") || auth.startsWith("NTLM")) {

            // NTLM/Kerberos/Negotiate authentication is not supported with HTTP/2.

            // Finish the stream with an error so QNetworkReply::finished is emitted.

            // Falling back to HTTP/1.1 is a separate, larger effort (QTBUG-143926).

            emit httpReply->headerChanged();

            emit httpReply->readyRead();

            const QNetworkReply::NetworkError error = isProxy

                    ? QNetworkReply::ProxyAuthenticationRequiredError

                    : QNetworkReply::AuthenticationRequiredError;

            finishStreamWithError(stream, error,

                                  m_connection->d_func()->errorDetail(error, m_socket));

            return false;

        }

        // Somewhat mimics parts of QHttpNetworkConnectionChannel::handleStatus

        bool resend = false;

        const bool authenticateHandled = m_connection->d_func()->handleAuthenticateChallenge(

                m_socket, httpReply, isProxy, resend);

        if (authenticateHandled) {

            if (resend) {

                httpReply->d_func()->eraseData();

                // Add the request back in queue, we'll retry later now that

                // we've gotten some username/password set on it:

                httpRequest.d->needResendWithCredentials = true;

                m_channel->h2RequestsToSend.insert(httpRequest.priority(), requestPair);

                httpReply->d_func()->clearHeaders();

                // If we have data we were uploading we need to reset it:

                if (auto *byteDevice = httpRequest.uploadByteDevice()) {

                    byteDevice->reset();

                    httpReplyPrivate->totallyUploadedData = 0;

                }

                // We automatically try to send new requests when the stream is

                // closed, so we don't need to call sendRequest ourselves.

                return true;

            } // else: we're just not resending the request.

            // @note In the http/1.x case we (at time of writing) call close()

            // for the connectionChannel (which is a bit weird, we could surely

            // reuse the open socket outside "connection:close"?), but in http2

            // we only have one channel, so we won't close anything.

        } else {

            // No authentication header or authentication isn't supported, but

            // we got a 401/407 so we cannot succeed. We need to emit signals

            // for headers and data, and then finishWithError.

            emit httpReply->headerChanged();

            emit httpReply->readyRead();

            QNetworkReply::NetworkError error = httpReply->statusCode() == 401

                    ? QNetworkReply::AuthenticationRequiredError

                    : QNetworkReply::ProxyAuthenticationRequiredError;

            finishStreamWithError(stream, QNetworkReply::AuthenticationRequiredError,

                                  m_connection->d_func()->errorDetail(error, m_socket));

        }

        return false;

    };

    // These statuses would in HTTP/1.1 be handled by

    // QHttpNetworkConnectionChannel::handleStatus. But because h2 has

    // multiple streams/requests in a single channel this structure does not

    // map properly to that function.

    bool authOk = true;

    switch (httpReply->statusCode()) {

    case 401:

        authOk = handleAuth(httpReply->headerField("www-authenticate"), false);

        break;

    case 407:

        authOk = handleAuth(httpReply->headerField("proxy-authenticate"), true);

        break;

    default:

        Q_UNREACHABLE();

    }

    if (authOk) {

        stream->sendRST_STREAM(CANCEL);

        clearStreamState(stream);

        stream->deleteLater();

    } // else: errors handled inside handleAuth

}

// Called when we have received a frame with the END_STREAM flag set

void QHttp2ProtocolHandler::finishStream(QHttp2Stream *stream, Qt::ConnectionType connectionType)

{

    if (stream->state() != QHttp2Stream::State::Closed)

        stream->sendRST_STREAM(CANCEL);

    auto &pair = requestReplyPairs[stream];

    auto *httpReply = pair.second;

    if (httpReply) {

        int statusCode = httpReply->statusCode();

        if (statusCode == 401 || statusCode == 407) {

            // handleAuthorization will either re-send the request or

            // finishWithError. In either case we don't want to emit finished

            // here.

            handleAuthorization(stream);

            return;

        }

        httpReply->disconnect(this);

        if (!pair.first.d->needResendWithCredentials) {

            if (connectionType == Qt::DirectConnection)

                emit httpReply->finished();

            else

                QMetaObject::invokeMethod(httpReply, &QHttpNetworkReply::finished, connectionType);

        }

    }

    clearStreamState(stream);

    qCDebug(QT_HTTP2) << "stream" << stream->streamID() << "closed";

    // Detach the reply and tear down the stream via canonical path, so a

    // later stray frame cannot fail an already-finished reply. tryRemoveReply()

    // also clears the reply->stream map, its sendRST_STREAM() does nothing on a

    // gracefully closed stream.

    if (!httpReply || !tryRemoveReply(httpReply)) {

        requestReplyPairs.remove(stream);

        stream->deleteLater();

    }

}

void QHttp2ProtocolHandler::handleGOAWAY(Http2Error errorCode, quint32 lastStreamID)

{

    qCDebug(QT_HTTP2) << "GOAWAY received, error code:" << errorCode << "last stream ID:"

                      << lastStreamID;

    if (errorCode == HTTP2_NO_ERROR) {

        // Graceful GOAWAY: the queued requests are sent on the next connection.

        // *noop*

    } else {

        // Error GOAWAY: the queued requests were never processed, so a retry could still

        // succeed, but something went wrong on this connection - report it to the user

        // rather than silently trying again.

        m_channel->emitFinishedWithError(QNetworkReply::ProtocolUnknownError,

                                         "GOAWAY received, cannot start a request");

        m_channel->h2RequestsToSend.clear();

    }

    // Active streams are not handled here: QHttp2Connection::handleGOAWAY() cancels the ones

    // the peer will not process and we pick them up through QHttp2Stream::errorOccurred.

}

void QHttp2ProtocolHandler::finishStreamWithError(QHttp2Stream *stream, Http2Error errorCode)

{

    QNetworkReply::NetworkError error = QNetworkReply::NoError;

    QString message;

    qt_error(errorCode, error, message);

    finishStreamWithError(stream, error, message);

}

void QHttp2ProtocolHandler::finishStreamWithError(QHttp2Stream *stream,

        QNetworkReply::NetworkError error, const QString &message)

{

    stream->sendRST_STREAM(CANCEL);

    const HttpMessagePair &pair = requestReplyPairs.value(stream);

    if (auto *httpReply = pair.second) {

        httpReply->disconnect(this);

        // TODO: error message must be translated!!! (tr)

        emit httpReply->finishedWithError(error, message);

    }

    clearStreamState(stream);

    stream->deleteLater();

    qCWarning(QT_HTTP2) << "stream" << stream->streamID() << "finished with error:" << message;

}

/*!

    \internal

    Creates a QHttp2Stream for the request, will return \nullptr if the stream

    could not be created for some reason, and will finish the reply if required.

*/

QHttp2Stream *QHttp2ProtocolHandler::createNewStream(const HttpMessagePair &message,

                                                     bool uploadDone)

{

    QUrl streamKey = urlkey_from_request(message.first);

    if (auto promisedStream = h2Connection->promisedStream(streamKey)) {

        Q_ASSERT(promisedStream->state() != QHttp2Stream::State::Closed);

        return promisedStream;

    }

    QH2Expected<QHttp2Stream *, QHttp2Connection::CreateStreamError>

            streamResult = h2Connection->createStream();

    if (!streamResult.ok()) {

        if (streamResult.error()

            == QHttp2Connection::CreateStreamError::MaxConcurrentStreamsReached) {

            // We have to wait for a stream to be closed before we can create a new one, so

            // we just return nullptr, the caller should not remove it from the queue.

            return nullptr;

        }

        qCDebug(QT_HTTP2) << "failed to create new stream:" << streamResult.error();

        auto *reply = message.second;

        const char *cstr = "Failed to initialize HTTP/2 stream with errorcode: %1";

        const QString errorString = QCoreApplication::translate("QHttp", cstr)

                                            .arg(QDebug::toString(streamResult.error()));

        emit reply->finishedWithError(QNetworkReply::ProtocolFailure, errorString);

        return nullptr;

    }

    QHttp2Stream *stream = streamResult.unwrap();

    if (!uploadDone) {

        if (auto *src = message.first.uploadByteDevice()) {

            connect(src, &QObject::destroyed, this, &QHttp2ProtocolHandler::_q_uploadDataDestroyed);

            streamIDs.insert(src, stream);

        }

    }

    auto *reply = message.second;

    QMetaObject::invokeMethod(reply, &QHttpNetworkReply::requestSent, Qt::QueuedConnection);

    connectStream(message, stream);

    return stream;

}

void QHttp2ProtocolHandler::connectStream(const HttpMessagePair &message, QHttp2Stream *stream)

{

    auto *reply = message.second;

    auto *replyPrivate = reply->d_func();

    replyPrivate->connection = m_connection;

    replyPrivate->connectionChannel = m_channel;

    reply->setHttp2WasUsed(true);

    QPointer<QHttp2Stream> &oldStream = streamIDs[reply];

    if (oldStream) {

        disconnect(oldStream, nullptr, this, nullptr);

        clearStreamState(oldStream);

    }

    oldStream = stream;

    requestReplyPairs.emplace(stream, message);

    QObject::connect(stream, &QHttp2Stream::headersReceived, this,

                     &QHttp2ProtocolHandler::handleHeadersReceived);

    QObject::connect(stream, &QHttp2Stream::dataReceived, this,

                     &QHttp2ProtocolHandler::handleDataReceived);

    QObject::connect(stream, &QHttp2Stream::errorOccurred, this,

                     [this, stream](Http2Error errorCode, const QString &errorString) {

                         qCWarning(QT_HTTP2)

                                 << "stream" << stream->streamID() << "error:" << errorString;

                         // A graceful GOAWAY cancels exactly the streams the peer will not

                         // process, so those requests can still be sent on a new connection.

                         // An error GOAWAY, or any other failure, keeps its own error.

                         if (const auto lastId = h2Connection->lastGoAwayStreamID();

                             errorCode == HTTP2_NO_ERROR && lastId

                             && stream->streamID() > *lastId) {

                             finishStreamWithError(

                                     stream, QNetworkReply::ContentReSendError,

                                     QCoreApplication::translate(

                                             "QHttp",

                                             "Server stopped accepting new streams before this "

                                             "stream was established"));

                         } else {

                             finishStreamWithError(stream, errorCode);

                         }

                     });

    QObject::connect(stream, &QHttp2Stream::stateChanged, this, [this](QHttp2Stream::State state) {

        if (state == QHttp2Stream::State::Closed) {

            // Try to send more requests if we have any

            if (!m_channel->h2RequestsToSend.empty()) {

                QMetaObject::invokeMethod(this, &QHttp2ProtocolHandler::sendRequest,

                                          Qt::QueuedConnection);

            }

        }

    });

}

void QHttp2ProtocolHandler::clearStreamState(QHttp2Stream *stream)

{

    auto it = requestReplyPairs.find(stream);

    if (it == requestReplyPairs.end())

        return;

    if (auto *reply = it->second)

        streamIDs.remove(reply);

    if (auto *uploadDevice = it->first.uploadByteDevice())

        streamIDs.remove(uploadDevice);

    requestReplyPairs.erase(it);

}

void QHttp2ProtocolHandler::initReplyFromPushPromise(const HttpMessagePair &message,

                                                     const QUrl &cacheKey)

{

    QHttp2Stream *promise = h2Connection->promisedStream(cacheKey);

    Q_ASSERT(promise);

    Q_ASSERT(message.second);

    message.second->setHttp2WasUsed(true);

    qCDebug(QT_HTTP2) << "found cached/promised response on stream" << promise->streamID();

    const bool replyFinished = promise->state() == QHttp2Stream::State::Closed;

    connectStream(message, promise);

    // Now that we have connect()ed, re-emit signals so that the reply

    // can be processed as usual:

    QByteDataBuffer downloadBuffer = promise->takeDownloadBuffer();

    if (const auto &headers = promise->receivedHeaders(); !headers.empty())

        emit promise->headersReceived(headers, replyFinished && downloadBuffer.isEmpty());

    if (!downloadBuffer.isEmpty()) {

        for (qsizetype i = 0; i < downloadBuffer.bufferCount(); ++i) {

            const bool streamEnded = replyFinished && i == downloadBuffer.bufferCount() - 1;

            emit promise->dataReceived(downloadBuffer[i], streamEnded);

        }

    }

}

void QHttp2ProtocolHandler::connectionError(Http2::Http2Error errorCode, const QString &message)

{

    Q_ASSERT(!message.isNull());

    qCCritical(QT_HTTP2) << "connection error:" << message;

    const auto error = qt_error(errorCode);

    m_channel->emitFinishedWithError(error, message);

    m_channel->h2RequestsToSend.clear();

    closeSession();

}

void QHttp2ProtocolHandler::closeSession()

{

    m_channel->close();

}

QT_END_NAMESPACE

#include "moc_qhttp2protocolhandler_p.cpp"