Msg File src/inet/transportlayer/quic/packet/FrameHeader.msg

Source code

//
// Copyright (C) 2019-2024 Timo Völker, Ekaterina Volodina
// Copyright (C) 2025 OpenSim Ltd.
//
// SPDX-License-Identifier: LGPL-3.0-or-later
//

import inet.common.packet.chunk.Chunk;
import inet.transportlayer.quic.packet.VariableLengthInteger;

cplusplus{{
    #include "VariableLengthInteger.h"
}}

namespace inet::quic;

enum FrameHeaderType {
    FRAME_HEADER_TYPE_PADDING = 0x00;
    FRAME_HEADER_TYPE_PING = 0x01;
    FRAME_HEADER_TYPE_STREAM = 0x0e;
    FRAME_HEADER_TYPE_ACK = 0x02;
    FRAME_HEADER_TYPE_CRYPTO = 0x06;
    FRAME_HEADER_TYPE_NEW_TOKEN = 0x07;
    FRAME_HEADER_TYPE_MAX_DATA = 0x10;
    FRAME_HEADER_TYPE_MAX_STREAM_DATA = 0x11;   
    FRAME_HEADER_TYPE_DATA_BLOCKED = 0x14;   
    FRAME_HEADER_TYPE_STREAM_DATA_BLOCKED = 0x15;
    FRAME_HEADER_TYPE_CONNECTION_CLOSE_QUIC = 0x1c;
    FRAME_HEADER_TYPE_CONNECTION_CLOSE_APP = 0x1d;
    FRAME_HEADER_TYPE_HANDSHAKE_DONE = 0x1e;
}

class FrameHeader extends FieldsChunk
{
    FrameHeaderType frameType;
}

class StreamFrameHeader extends FrameHeader
{
    frameType = FRAME_HEADER_TYPE_STREAM;
    bool finBit; // not a real field. Draft encodes this bit into type field.
    VariableLengthInteger streamId;
    VariableLengthInteger offset;
    VariableLengthInteger length;
}
cplusplus(StreamFrameHeader) {{
  public:
    static const size_t MAX_HEADER_SIZE = 1 + 8 + 8 + 8;
    static const size_t MIN_HEADER_SIZE = 1 + 1 + 1 + 1;

    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(streamId) + getVariableLengthIntegerSize(offset) + getVariableLengthIntegerSize(length);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "STREAM[streamId=" << streamId
            << ", offset=" << offset
            << ", length=" << length
            << "]";
        return os.str();
    }
}}

struct AckRange
{
    VariableLengthInteger gap;
    VariableLengthInteger ackRange;
};

class AckFrameHeader extends FrameHeader
{
    frameType = FRAME_HEADER_TYPE_ACK;
    VariableLengthInteger largestAck;
    VariableLengthInteger ackDelay;
    VariableLengthInteger ackRangeCount;
    VariableLengthInteger firstAckRange;
    AckRange ackRange[];
    //uint64_t ecnCounts;
    //uint64_t ecnCounts[];
}
cplusplus(AckFrameHeader) {{
  public:
    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(largestAck) + getVariableLengthIntegerSize(ackDelay) + getVariableLengthIntegerSize(ackRangeCount) + getVariableLengthIntegerSize(firstAckRange);
        for (int i=0; i<getAckRangeArraySize(); i++) {
            const AckRange& ackRangeItem = getAckRange(i);
            len += getVariableLengthIntegerSize(ackRangeItem.gap);
            len += getVariableLengthIntegerSize(ackRangeItem.ackRange);
        }
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "ACK[largest_ack=" << largestAck
            << ", ack_delay=" << ackDelay
            << ", ack_range_count=" << ackRangeCount
            << ", first_ack_range=" << firstAckRange;

		for (int i=0; i<getAckRangeArraySize(); i++) {
            const AckRange& ackRangeItem = getAckRange(i);
            os << ", (gap=" << ackRangeItem.gap
                << ", ack_range=" << ackRangeItem.ackRange
                << ")";
        }
        os << "]";
        return os.str();
    }
}}

class MaxDataFrameHeader extends FrameHeader
{
	frameType = FRAME_HEADER_TYPE_MAX_DATA;
	VariableLengthInteger maximumData;
} 
cplusplus(MaxDataFrameHeader) {{
  public:
    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(maximumData);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "MAX_DATA[maximumData=" << maximumData << "]";
        return os.str();
    }
}}

class MaxStreamDataFrameHeader extends FrameHeader
{
	frameType = FRAME_HEADER_TYPE_MAX_STREAM_DATA;	
	VariableLengthInteger streamId;
	VariableLengthInteger maximumStreamData;
}    

cplusplus(MaxStreamDataFrameHeader) {{
  public:
    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(streamId) + getVariableLengthIntegerSize(maximumStreamData);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "MAX_STREAM_DATA[streamId=" << streamId << ", maximumStreamData=" << maximumStreamData << "]";
        return os.str();
    }
}}

class DataBlockedFrameHeader extends FrameHeader
{
	frameType = FRAME_HEADER_TYPE_DATA_BLOCKED;	
	VariableLengthInteger dataLimit;
}    

cplusplus(DataBlockedFrameHeader) {{
  public:
    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(dataLimit);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "DATA_BLOCKED[dataLimit=" << dataLimit << "]";
        return os.str();
    }
}}

class StreamDataBlockedFrameHeader extends FrameHeader
{
	frameType = FRAME_HEADER_TYPE_STREAM_DATA_BLOCKED;	
	VariableLengthInteger streamId;
	VariableLengthInteger streamDataLimit;
}    

cplusplus(StreamDataBlockedFrameHeader) {{
  public:
    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(streamId) + getVariableLengthIntegerSize(streamDataLimit);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "STREAM_DATA_BLOCKED[streamId=" << streamId << ", streamDataLimit=" << streamDataLimit << "]";
        return os.str();
    }
}}

class PingFrameHeader extends FrameHeader
{
    chunkLength = B(1);
    frameType = FRAME_HEADER_TYPE_PING;
}

class PaddingFrameHeader extends FrameHeader
{
    chunkLength = B(1);
    frameType = FRAME_HEADER_TYPE_PADDING;
}
cplusplus(PaddingFrameHeader) {{
  public:
    void setLength(int lengthInByte) {
        this->setChunkLength(B(lengthInByte));
    }
}}

class CryptoFrameHeader extends FrameHeader
{
    frameType = FRAME_HEADER_TYPE_CRYPTO;
    VariableLengthInteger offset;
    VariableLengthInteger length;
    bool containsTransportParameters = false;
}
cplusplus(CryptoFrameHeader) {{
  public:
    static const size_t MAX_HEADER_SIZE = 1 + 8 + 8;
    static const size_t MIN_HEADER_SIZE = 1 + 1 + 1;

    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(offset) + getVariableLengthIntegerSize(length);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "CRYPTO[offset=" << offset
            << ", length=" << length
            << "]";
        return os.str();
    }
}}

class TransportParametersExtension extends FieldsChunk
{
    VariableLengthInteger initialMaxData;
    VariableLengthInteger initialMaxStreamDataBidiLocal;
    VariableLengthInteger initialMaxStreamDataBidiRemote;
    VariableLengthInteger initialMaxStreamDataUni;
}
cplusplus(TransportParametersExtension) {{
  public:
    void calcChunkLength() {
        int64_t len = getVariableLengthIntegerSize(initialMaxData) \
                      + getVariableLengthIntegerSize(initialMaxStreamDataBidiLocal) \
                      + getVariableLengthIntegerSize(initialMaxStreamDataBidiRemote) \
                      + getVariableLengthIntegerSize(initialMaxStreamDataUni);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "TransportParametersExtension";
        return os.str();
    }
}}

class HandshakeDoneFrameHeader extends FrameHeader
{
    chunkLength = B(1);
    frameType = FRAME_HEADER_TYPE_HANDSHAKE_DONE;
}

class ConnectionCloseFrameHeader extends FrameHeader
{
    frameType = FRAME_HEADER_TYPE_CONNECTION_CLOSE_QUIC;
    VariableLengthInteger errorCode;
}
cplusplus(ConnectionCloseFrameHeader) {{
  public:
    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(errorCode);
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "CONNECTION_CLOSE["
            << (frameType == FRAME_HEADER_TYPE_CONNECTION_CLOSE_QUIC ? "QUIC" : "APP")
            << ", errorCode=" << errorCode
            << "]";
        return os.str();
    }
}}

class NewTokenFrameHeader extends FrameHeader
{
    frameType = FRAME_HEADER_TYPE_NEW_TOKEN;
    VariableLengthInteger tokenLength;
    uint32_t token;
}
cplusplus(NewTokenFrameHeader) {{
  public:
    void calcChunkLength() {
        int64_t len = 1 + getVariableLengthIntegerSize(tokenLength) + tokenLength;
        this->setChunkLength(B(len));
    }
    std::string str() const override {
        std::ostringstream os;
        os << "NEW_TOKEN["
            << "token=" << token
            << "]";
        return os.str();
    }
}}

This documentation is released under the Creative Commons license