QpackEncoder Class — netty Architecture

Source Code

codec-http3/src/main/java/io/netty/handler/codec/http3/QpackEncoder.java lines 36–544

final class QpackEncoder {
    private static final QpackException INVALID_SECTION_ACKNOWLEDGMENT =
            QpackException.newStatic(QpackDecoder.class, "sectionAcknowledgment(...)",
                    "QPACK - section acknowledgment received for unknown stream.");
    private static final int DYNAMIC_TABLE_ENCODE_NOT_DONE = -1;
    private static final int DYNAMIC_TABLE_ENCODE_NOT_POSSIBLE = -2;

    private final QpackHuffmanEncoder huffmanEncoder;
    private final QpackEncoderDynamicTable dynamicTable;
    private int maxBlockedStreams;
    private int blockedStreams;
    private LongObjectHashMap<Queue<Indices>> streamSectionTrackers;

    QpackEncoder() {
        this(new QpackEncoderDynamicTable());
    }

    QpackEncoder(QpackEncoderDynamicTable dynamicTable) {
        huffmanEncoder = new QpackHuffmanEncoder();
        this.dynamicTable = dynamicTable;
    }

    /**
     * Encode the header field into the header block.
     *
     * TODO: do we need to support sensitivity detector?
     */
    void encodeHeaders(QpackAttributes qpackAttributes, ByteBuf out, ByteBufAllocator allocator, long streamId,
                       Http3Headers headers) {
        final int base = dynamicTable.insertCount();
        // Allocate a new buffer as we have to go back and write a variable length base and required insert count
        // later.
        ByteBuf tmp = allocator.buffer();
        try {
            int maxDynamicTblIdx = -1;
            int requiredInsertCount = 0;
            Indices dynamicTableIndices = null;
            for (Map.Entry<CharSequence, CharSequence> header : headers) {
                CharSequence name = header.getKey();
                CharSequence value = header.getValue();
                int dynamicTblIdx = encodeHeader(qpackAttributes, tmp, base, name, value);
                if (dynamicTblIdx >= 0) {
                    int req = dynamicTable.addReferenceToEntry(name, value, dynamicTblIdx);
                    if (dynamicTblIdx > maxDynamicTblIdx) {
                        maxDynamicTblIdx = dynamicTblIdx;
                        requiredInsertCount = req;
                    }
                    if (dynamicTableIndices == null) {
                        dynamicTableIndices = new Indices();
                    }
                    dynamicTableIndices.add(dynamicTblIdx);
                }
            }

            // Track all the indices that we need to ack later.
            if (dynamicTableIndices != null) {
                assert streamSectionTrackers != null;
                streamSectionTrackers.computeIfAbsent(streamId, __ -> new ArrayDeque<>())
                        .add(dynamicTableIndices);
            }

            // https://www.rfc-editor.org/rfc/rfc9204.html#name-encoded-field-section-prefi
            //   0   1   2   3   4   5   6   7
            // +---+---+---+---+---+---+---+---+
            // |   Required Insert Count (8+)  |
            // +---+---------------------------+
            // | S |      Delta Base (7+)      |
            // +---+---------------------------+
            encodePrefixedInteger(out, (byte) 0b0, 8, dynamicTable.encodedRequiredInsertCount(requiredInsertCount));
            if (base >= requiredInsertCount) {
                encodePrefixedInteger(out, (byte) 0b0, 7, base - requiredInsertCount);
            } else {
                encodePrefixedInteger(out, (byte) 0b1000_0000, 7, requiredInsertCount - base - 1);
            }
            out.writeBytes(tmp);
        } finally {
            tmp.release();
        }
    }

    void configureDynamicTable(QpackAttributes attributes, long maxTableCapacity, int blockedStreams)