qhttp2connection_p.h

// Copyright (C) 2023 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:significant reason:default

#ifndef HTTP2CONNECTION_P_H

#define HTTP2CONNECTION_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API. It exists for the convenience

// of the Network Access API. This header file may change from

// version to version without notice, or even be removed.

//

// We mean it.

//

#include <private/qtnetworkglobal_p.h>

#include <QtCore/qobject.h>

#include <QtCore/qhash.h>

#include <QtCore/qset.h>

#include <QtCore/qvarlengtharray.h>

#include <QtCore/qxpfunctional.h>

#include <QtNetwork/qhttp2configuration.h>

#include <QtNetwork/qtcpsocket.h>

#include <private/http2protocol_p.h>

#include <private/http2streams_p.h>

#include <private/http2frames_p.h>

#include <private/hpack_p.h>

#include <variant>

#include <optional>

#include <type_traits>

#include <limits>

class tst_QHttp2Connection;

QT_BEGIN_NAMESPACE

template <typename T, typename Err>

class QH2Expected

    static_assert(!std::is_same_v<T, Err>, "T and Err must be different types");

public:

    // Rule Of Zero applies

    QH2Expected(T &&value) : m_data(std::move(value)) { }

    QH2Expected(const T &value) : m_data(value) { }

    QH2Expected(Err &&error) : m_data(std::move(error)) { }

    QH2Expected(const Err &error) : m_data(error) { }

    QH2Expected &operator=(T &&value)

        m_data = std::move(value);

        return *this;

    QH2Expected &operator=(const T &value)

        m_data = value;

        return *this;

    QH2Expected &operator=(Err &&error)

        m_data = std::move(error);

        return *this;

    QH2Expected &operator=(const Err &error)

        m_data = error;

        return *this;

    T unwrap() const

        Q_ASSERT(ok());

        return std::get<T>(m_data);

    Err error() const

        Q_ASSERT(has_error());

        return std::get<Err>(m_data);

    bool ok() const noexcept { return std::holds_alternative<T>(m_data); }

    bool has_value() const noexcept { return ok(); }

    bool has_error() const noexcept { return std::holds_alternative<Err>(m_data); }

    void clear() noexcept { m_data.reset(); }

private:

    std::variant<T, Err> m_data;

};

class QHttp2Connection;

class Q_NETWORK_EXPORT QHttp2Stream : public QObject

    Q_OBJECT

    Q_DISABLE_COPY_MOVE(QHttp2Stream)

public:

    enum class State { Idle, ReservedRemote, Open, HalfClosedLocal, HalfClosedRemote, Closed };

    Q_ENUM(State)

    constexpr static quint8 DefaultPriority = 127;

    struct Configuration

        bool useDownloadBuffer = true;

        bool useHeaderBuffer = true;

};

    ~QHttp2Stream() noexcept;

    // HTTP2 things

    quint32 streamID() const noexcept { return m_streamID; }

    // Are we waiting for a larger send window before sending more data?

    bool isUploadBlocked() const noexcept;

    bool isUploadingDATA() const noexcept { return m_uploadByteDevice != nullptr; }

    State state() const noexcept { return m_state; }

    bool isActive() const noexcept { return m_state != State::Closed && m_state != State::Idle; }

    bool isPromisedStream() const noexcept { return m_isReserved; }

    bool wasReset() const noexcept { return m_RST_STREAM_received.has_value() ||

                                     m_RST_STREAM_sent.has_value(); }

    bool wasResetbyPeer() const noexcept { return m_RST_STREAM_received.has_value(); }

    quint32 RST_STREAMCodeReceived() const noexcept { return m_RST_STREAM_received.value_or(0); }

    quint32 RST_STREAMCodeSent() const noexcept { return m_RST_STREAM_sent.value_or(0); }

    // Just the list of headers, as received, may contain duplicates:

    HPack::HttpHeader receivedHeaders() const noexcept { return m_headers; }

    QByteDataBuffer downloadBuffer() const noexcept { return m_downloadBuffer; }

    QByteDataBuffer takeDownloadBuffer() noexcept { return std::exchange(m_downloadBuffer, {}); }

    void clearDownloadBuffer() { m_downloadBuffer.clear(); }

    Configuration configuration() const { return m_configuration; }

Q_SIGNALS:

    void headersReceived(const HPack::HttpHeader &headers, bool endStream);

    void headersUpdated();

    void errorOccurred(Http2::Http2Error errorCode, const QString &errorString);

    void stateChanged(QHttp2Stream::State newState);

    void promisedStreamReceived(quint32 newStreamID);

    void uploadBlocked();

    void dataReceived(const QByteArray &data, bool endStream);

    void rstFrameReceived(quint32 errorCode);

    void bytesWritten(qint64 bytesWritten);

    void uploadDeviceError(const QString &errorString);

    void uploadFinished();

public Q_SLOTS:

    bool sendRST_STREAM(Http2::Http2Error errorCode);

    bool sendHEADERS(const HPack::HttpHeader &headers, bool endStream,

                     quint8 priority = DefaultPriority);

    bool sendDATA(const QByteArray &payload, bool endStream);

    bool sendDATA(QIODevice *device, bool endStream);

    bool sendDATA(QNonContiguousByteDevice *device, bool endStream);

    void sendWINDOW_UPDATE(quint32 delta);

private Q_SLOTS:

    void maybeResumeUpload();

    void uploadDeviceReadChannelFinished();

    void uploadDeviceDestroyed();

private:

    friend class QHttp2Connection;

    QHttp2Stream(QHttp2Connection *connection, quint32 streamID,

                 Configuration configuration) noexcept;

    [[nodiscard]] QHttp2Connection *getConnection() const

        return qobject_cast<QHttp2Connection *>(parent());

    enum class StateTransition {

        Open,

        CloseLocal,

        CloseRemote,

        RST,

};

    void setState(State newState);

    void transitionState(StateTransition transition);

    void internalSendDATA();

    void finishSendDATA();

    void handleDATA(const Http2::Frame &inboundFrame);

    void handleHEADERS(Http2::FrameFlags frameFlags, const HPack::HttpHeader &headers);

    void handleRST_STREAM(const Http2::Frame &inboundFrame);

    void handleWINDOW_UPDATE(const Http2::Frame &inboundFrame);

    void finishWithError(Http2::Http2Error errorCode, const QString &message);

    void finishWithError(Http2::Http2Error errorCode);

    void streamError(Http2::Http2Error errorCode, const QString &message);

    // Keep it const since it never changes after creation

    const quint32 m_streamID = 0;

    qint32 m_recvWindow = 0;

    qint32 m_sendWindow = 0;

    bool m_endStreamAfterDATA = false;

    std::optional<quint32> m_RST_STREAM_received;

    std::optional<quint32> m_RST_STREAM_sent;

    QIODevice *m_uploadDevice = nullptr;

    QNonContiguousByteDevice *m_uploadByteDevice = nullptr;

    QByteDataBuffer m_downloadBuffer;

    State m_state = State::Idle;

    HPack::HttpHeader m_headers;

    bool m_isReserved = false;

    bool m_owningByteDevice = false;

    const Configuration m_configuration;

    friend tst_QHttp2Connection;

};

class Q_NETWORK_EXPORT QHttp2Connection : public QObject

    Q_OBJECT

    Q_DISABLE_COPY_MOVE(QHttp2Connection)

public:

    enum class CreateStreamError {

        MaxConcurrentStreamsReached,

        StreamIdsExhausted,

        ReceivedGOAWAY,

        UnknownError,

};

    Q_ENUM(CreateStreamError)

    enum class PingState {

        Ping,

        PongSignatureIdentical,

        PongSignatureChanged,

        PongNoPingSent, // We got an ACKed ping but had not sent any

};

    // For a pre-established connection:

    [[nodiscard]] static QHttp2Connection *

    createUpgradedConnection(QIODevice *socket, const QHttp2Configuration &config);

    // For a new connection, potential TLS handshake must already be finished:

    [[nodiscard]] static QHttp2Connection *createDirectConnection(QIODevice *socket,

                                                                const QHttp2Configuration &config);

    [[nodiscard]] static QHttp2Connection *

    createDirectServerConnection(QIODevice *socket, const QHttp2Configuration &config);

    ~QHttp2Connection();

    [[nodiscard]] QH2Expected<QHttp2Stream *, CreateStreamError> createStream()

        return createStream(QHttp2Stream::Configuration{});

    [[nodiscard]] QH2Expected<QHttp2Stream *, CreateStreamError>

    createStream(QHttp2Stream::Configuration config);

    QHttp2Stream *getStream(quint32 streamId) const;

    QHttp2Stream *promisedStream(const QUrl &streamKey) const

        if (quint32 id = m_promisedStreams.value(streamKey, 0); id)

            return m_streams.value(id);

        return nullptr;

    void close(Http2::Http2Error errorCode = Http2::HTTP2_NO_ERROR);

    bool isGoingAway() const noexcept { return m_goingAway; }

    // Set once a GOAWAY has been received; the peer did not process streams above this ID.

    std::optional<quint32> lastGoAwayStreamID() const noexcept { return m_lastGoAwayLastStreamID; }

    quint32 maxConcurrentStreams() const noexcept { return m_maxConcurrentStreams; }

    quint32 peerMaxConcurrentStreams() const noexcept { return m_peerMaxConcurrentStreams; }

    quint32 maxHeaderListSize() const noexcept { return m_maxHeaderListSize; }

    bool isUpgradedConnection() const noexcept { return m_upgradedConnection; }

    bool setSessionReceiveWindowSize(qint32 size);

    quint64 totalBytesReceivedDATA() const noexcept { return m_totalBytesReceivedDATA; }

Q_SIGNALS:

    void newIncomingStream(QHttp2Stream *stream);

    void newPromisedStream(QHttp2Stream *stream);

    void errorReceived(/*@future: add as needed?*/); // Connection errors only, no stream-specific errors

    void connectionClosed();

    void settingsFrameReceived();

    void pingFrameReceived(QHttp2Connection::PingState state);

    void errorOccurred(Http2::Http2Error errorCode, const QString &errorString);

    void receivedGOAWAY(Http2::Http2Error errorCode, quint32 lastStreamID);

    void receivedEND_STREAM(quint32 streamID);

    void incomingStreamErrorOccured(CreateStreamError error);

public Q_SLOTS:

    bool sendPing();

    bool sendPing(QByteArrayView data);

    void handleReadyRead();

    void handleConnectionClosure();

private:

    friend class QHttp2Stream;

    [[nodiscard]] QIODevice *getSocket() const { return qobject_cast<QIODevice *>(parent()); }

    QH2Expected<QHttp2Stream *, QHttp2Connection::CreateStreamError>

    createLocalStreamInternal(QHttp2Stream::Configuration = {});

    QHttp2Stream *createStreamInternal_impl(quint32 streamID, QHttp2Stream::Configuration = {});

    bool isInvalidStream(quint32 streamID) noexcept;

    bool streamWasResetLocally(quint32 streamID) noexcept;

    Q_ALWAYS_INLINE

    bool streamIsIgnored(quint32 streamID) const noexcept;

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

                         bool logAsError = true);

    void setH2Configuration(QHttp2Configuration config);

    void closeSession();

    void registerStreamAsResetLocally(quint32 streamID);

    qsizetype numActiveStreamsImpl(quint32 mask) const noexcept;

    qsizetype numActiveRemoteStreams() const noexcept;

    qsizetype numActiveLocalStreams() const noexcept;

    bool sendClientPreface();

    bool sendSETTINGS();

    bool sendServerPreface();

    bool serverCheckClientPreface();

    bool sendWINDOW_UPDATE(quint32 streamID, quint32 delta);

    void sendClientGracefulShutdownGoaway();

    void sendInitialServerGracefulShutdownGoaway();

    void sendFinalServerGracefulShutdownGoaway();

    bool sendGOAWAYFrame(Http2::Http2Error errorCode, quint32 lastSreamID);

    void maybeCloseOnGoingAway();

    bool sendSETTINGS_ACK();

    void handleDATA();

    void handleHEADERS();

    void handlePRIORITY();

    void handleRST_STREAM();

    void handleSETTINGS();

    void handlePUSH_PROMISE();

    void handlePING();

    void handleGOAWAY();

    void handleWINDOW_UPDATE();

    void handleCONTINUATION();

    void handleContinuedHEADERS();

    bool validateHeaderListSize(const Http2::Frame &frame);

    bool acceptSetting(Http2::Settings identifier, quint32 newValue);

    bool readClientPreface();

    explicit QHttp2Connection(QIODevice *socket);

    enum class Type { Client, Server } m_connectionType = Type::Client;

    bool waitingForSettingsACK = false;

    static constexpr quint32 maxAcceptableTableSize = 16 * HPack::FieldLookupTable::DefaultSize;

    // HTTP/2 4.3: Header compression is stateful. One compression context and

    // one decompression context are used for the entire connection.

    HPack::Decoder decoder = HPack::Decoder(HPack::FieldLookupTable::DefaultSize);

    HPack::Encoder encoder = HPack::Encoder(HPack::FieldLookupTable::DefaultSize, true);

    // If we receive SETTINGS_HEADER_TABLE_SIZE in a SETTINGS frame we have to perform a dynamic

    // table size update on the _next_ HEADER block we send.

    // Because this only happens on the next block we may have multiple pending updates, so we must

    // notify of the _smallest_ one followed by the _final_ one. We keep them sorted in that order.

    // @future: keep in mind if we add support for sending PUSH_PROMISE because it is a HEADER block

    std::array<std::optional<quint32>, 2> pendingTableSizeUpdates;

    QHttp2Configuration m_config;

    QHash<quint32, QPointer<QHttp2Stream>> m_streams;

    QSet<quint32> m_blockedStreams;

    QHash<QUrl, quint32> m_promisedStreams;

    QList<quint32> m_resetStreamIDs;

    std::optional<QByteArray> m_lastPingSignature = std::nullopt;

    quint32 m_nextStreamID = 1;

    // Peer's max frame size (this min is the default value

    // we start with, that can be updated by SETTINGS frame):

    quint32 maxFrameSize = Http2::minPayloadLimit;

    Http2::FrameReader frameReader;

    Http2::Frame inboundFrame;

    Http2::FrameWriter frameWriter;

    // Temporary storage to assemble HEADERS' block

    // from several CONTINUATION frames ...

    bool continuationExpected = false;

    std::vector<Http2::Frame> continuedFrames;

    quint32 m_headerBlockSize = 0;

    // Control flow:

    // This is how many concurrent streams our peer allows us, 100 is the

    // initial value, can be updated by the server's SETTINGS frame(s):

    quint32 m_peerMaxConcurrentStreams = Http2::maxConcurrentStreams;

    // While we allow sending SETTTINGS_MAX_CONCURRENT_STREAMS to limit our peer,

    // it's just a hint and we do not actually enforce it (and we can continue

    // sending requests and creating streams while maxConcurrentStreams allows).

    // This is how many concurrent streams we allow our peer to create

    // This value is specified in QHttp2Configuration when creating the connection

    quint32 m_maxConcurrentStreams = Http2::maxConcurrentStreams;

    // This is our (client-side) maximum possible receive window size, we set

    // it in a ctor from QHttp2Configuration, it does not change after that.

    // The default is 64Kb:

    qint32 maxSessionReceiveWindowSize = Http2::defaultSessionWindowSize;

    // Our session current receive window size, updated in a ctor from

    // QHttp2Configuration. Signed integer since it can become negative

    // (it's still a valid window size).

    qint32 sessionReceiveWindowSize = Http2::defaultSessionWindowSize;

    // Our per-stream receive window size, default is 64 Kb, will be updated

    // from QHttp2Configuration. Again, signed - can become negative.

    qint32 streamInitialReceiveWindowSize = Http2::defaultSessionWindowSize;

    quint64 m_totalBytesReceivedDATA = 0;

    // These are our peer's receive window sizes, they will be updated by the

    // peer's SETTINGS and WINDOW_UPDATE frames, defaults presumed to be 64Kb.

    qint32 sessionSendWindowSize = Http2::defaultSessionWindowSize;

    qint32 streamInitialSendWindowSize = Http2::defaultSessionWindowSize;

    // Our peer's header size limitations. It's unlimited by default, but can

    // be changed via peer's SETTINGS frame.

    quint32 m_maxHeaderListSize = (std::numeric_limits<quint32>::max)();

    // The limit we advertise via SETTINGS_MAX_HEADER_LIST_SIZE is enforced on

    // incoming header blocks both before HPACK decoding (compressed size) and

    // during HPACK decoding (decoded size).

    bool m_upgradedConnection = false;

    bool m_goingAway = false;

    bool pushPromiseEnabled = false;

    quint32 m_lastIncomingStreamID = Http2::connectionStreamID;

    // Gets lowered when/if we send GOAWAY:

    quint32 m_lastStreamToProcess = Http2::lastValidStreamID;

    static constexpr std::chrono::duration GoawayGracePeriod = std::chrono::seconds(60);

    QDeadlineTimer m_goawayGraceTimer;

    std::optional<quint32> m_lastGoAwayLastStreamID;

    bool m_connectionAborted = false;

    enum class GracefulShutdownState {

        None,

        AwaitingPriorPing,

        AwaitingShutdownPing,

        FinalGOAWAYSent,

};

    GracefulShutdownState m_gracefulShutdownState = GracefulShutdownState::None;

    bool m_prefaceSent = false;

    // Server-side only:

    bool m_waitingForClientPreface = false;

    friend tst_QHttp2Connection;

};

QT_END_NAMESPACE

#endif // HTTP2CONNECTION_P_H

Revision control

Copy as Markdown