protocolhttp2.h

/*
 * SPDX-FileCopyrightText: (C) 2018 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef PROTOCOLHTTP2_H
#define PROTOCOLHTTP2_H

#include "hpack.h"
#include "protocol.h"
#include "socket.h"

#include <context.h>
#include <enginerequest.h>

#include <QObject>

// namespace Cutelyst {
// class Headers;
// }

class QEventLoop;
namespace Cutelyst {

class H2Frame
{
public:
    quint32 len;
    quint32 streamId;
    quint8 type;
    quint8 flags;
};

class ProtoRequestHttp2;
class H2Stream final : public Cutelyst::EngineRequest
{
public:
    enum State { Idle, Open, HalfClosed, Closed };
    H2Stream(quint32 streamId, qint32 initialWindowSize, ProtoRequestHttp2 *protoRequestH2);
    ~H2Stream() override;

    qint64 doWrite(const char *data, qint64 len) override final;

    bool writeHeaders(quint16 status, const Cutelyst::Headers &headers) override final;

    void processingFinished() override final;

    void windowUpdated();

    QEventLoop *loop = nullptr;
    QByteArray scheme;
    ProtoRequestHttp2 *protoRequest;
    quint32 streamId;
    qint32 windowSize    = 65535;
    qint64 contentLength = -1;
    qint32 dataSent      = 0;
    qint64 consumedData  = 0;
    quint8 state         = Idle;
    bool gotPath         = false;
};

class ProtoRequestHttp2 final : public ProtocolData
{
    Q_GADGET
public:
    ProtoRequestHttp2(Cutelyst::Socket *sock, int bufferSize);
    ~ProtoRequestHttp2() override;

    void setupNewConnection(Cutelyst::Socket *sock) override final;

    inline void resetData() override final
    {
        ProtocolData::resetData();

        stream_id = 0;
        pktsize   = 0;
        delete hpack;
        hpack = nullptr;

        for (const auto &stream : std::as_const(streams)) {
            // If we deleteLater the context, there might
            // be an event that tries to finalize the request
            // and it will encounter a null context pointer
            delete stream->context;
            delete stream;
        }

        streams.clear();

        headersBuffer.clear();
        maxStreamId               = 0;
        streamForContinuation     = 0;
        dataSent                  = 0;
        windowSize                = 65535;
        settingsInitialWindowSize = 65535;
        canPush                   = false;
    }

    quint32 stream_id = 0;
    quint32 pktsize   = 0;

    QByteArray headersBuffer;
    HPack *hpack                     = nullptr;
    quint64 streamForContinuation    = 0;
    quint32 maxStreamId              = 0;
    qint32 dataSent                  = 0;
    qint32 windowSize                = 65535;
    qint32 settingsInitialWindowSize = 65535;
    quint32 settingsMaxFrameSize     = 16384;
    quint8 processing                = 0;
    bool canPush                     = true;

    QHash<quint32, H2Stream *> streams;
};

class ProtocolHttp2 final : public Protocol
{
public:
    explicit ProtocolHttp2(Server *server);
    ~ProtocolHttp2() override;

    Type type() const override;

    void parse(Cutelyst::Socket *sock, QIODevice *io) const override final;

    ProtocolData *createData(Cutelyst::Socket *sock) const override final;

    int parseSettings(ProtoRequestHttp2 *request, QIODevice *io, const H2Frame &fr) const;
    int parseData(ProtoRequestHttp2 *request, QIODevice *io, const H2Frame &fr) const;
    int parseHeaders(ProtoRequestHttp2 *request, QIODevice *io, const H2Frame &fr) const;
    int parsePriority(const ProtoRequestHttp2 *request, QIODevice *io, const H2Frame &fr) const;
    int parsePing(const ProtoRequestHttp2 *request, QIODevice *io, const H2Frame &fr) const;
    int parseRstStream(ProtoRequestHttp2 *request, QIODevice *io, const H2Frame &fr) const;
    int parseWindowUpdate(ProtoRequestHttp2 *request, QIODevice *io, const H2Frame &fr) const;

    int sendGoAway(QIODevice *io, quint32 lastStreamId, quint32 error) const;
    int sendRstStream(QIODevice *io, quint32 streamId, quint32 error) const;
    int sendSettings(QIODevice *io, const std::vector<std::pair<quint16, quint32>> &settings) const;
    int sendSettingsAck(QIODevice *io) const;
    int sendPing(QIODevice *io, quint8 flags, const char *data = nullptr, qint32 dataLen = 0) const;
    int sendData(QIODevice *io,
                 quint32 streamId,
                 qint32 flags,
                 const char *data,
                 qint32 dataLen) const;
    int sendFrame(QIODevice *io,
                  quint8 type,
                  quint8 flags     = 0,
                  quint32 streamId = 0,
                  const char *data = nullptr,
                  qint32 dataLen   = 0) const;

    void queueStream(Cutelyst::Socket *socket, H2Stream *stream) const;

    bool
        upgradeH2C(Cutelyst::Socket *socket, QIODevice *io, const Cutelyst::EngineRequest &request);

public:
    quint32 m_maxFrameSize;
    qint32 m_headerTableSize;
};

} // namespace Cutelyst

#endif // PROTOCOLHTTP2_H