dyntable.h

#ifndef QPACK_DYNTABLE_H
#define QPACK_DYNTABLE_H
 
#include "app/qpack/qpack/field.h"
 
/* RFC 9204 3.2. QPACK dynamic table: inserted (name, value) entries kept
 * back to back in a byte ring the size of the largest capacity the table
 * can be given, so the capacity is the only limit on an entry (3.2.2).
 * Absolute indices grow from 0 with each insert; old entries are evicted
 * when capacity is exceeded. No allocation, no libc. */

#define QPACK_DYN_MAX_CAPACITY 2016
#define QPACK_DYN_MAX_ENTRIES (QPACK_DYN_MAX_CAPACITY / 32)

typedef struct {
  u16 off;       
  u16 name_len;  
  u16 value_len; 
} qpack_dyn_entry;

typedef struct {
  u8              bytes[2 * QPACK_DYN_MAX_CAPACITY];
  qpack_dyn_entry ring[QPACK_DYN_MAX_ENTRIES]; 
  usz             head;     
  usz             count;    
  usz             tail;     
  u64             dropped;  
  usz             size;     
  usz             capacity; 
  u64 max_capacity;
} qpack_dyn;
 
/* RFC 9204 3.2. Initialise an empty table with the given byte capacity
 * (clamped to QPACK_DYN_MAX_CAPACITY). */
void qpack_dyn_init(qpack_dyn* t, usz capacity);
 
/* RFC 9204 3.2 / 3.2.1. Insert the (name, value) pair, evicting oldest
 * entries as needed to fit. Returns 1 on success, 0 if the entry cannot fit
 * even in an empty table. f must not view this table's own bytes: copy a
 * referenced entry out first, since eviction may reuse them. */
int qpack_dyn_insert(qpack_dyn* t, const qpack_field* f);
 
/* RFC 9204 3.2. Borrowed views of the live entry `off` places after the
 * oldest (off < t->count); valid until the next insert. */
void qpack_dyn_entry_at(const qpack_dyn* t, usz off, qpack_field* out);
 
/* RFC 9204 3.2.1. Current total size in bytes. */
usz qpack_dyn_size(const qpack_dyn* t);
 
/* RFC 9204 3.2.2. Apply a new dynamic table capacity from a received Set
 * Dynamic Table Capacity instruction (Section 4.3.1) once it has already
 * passed qpack_capacity_within_limit: evicts entries from the end of
 * the table until its size is at most new_capacity (a no-op if the
 * capacity is being raised, or set to 0 to clear the table entirely).
 * Clamped to QPACK_DYN_MAX_CAPACITY. */
void qpack_dyn_set_capacity(qpack_dyn* t, usz new_capacity);
 
/* RFC 9204 4.3.1. A received Set Dynamic Table Capacity instruction's value is
 * valid only up to the limit the server advertised in
 * SETTINGS_QPACK_MAX_TABLE_CAPACITY. Returns 1 if capacity is within that
 * limit, 0 if it exceeds it -- the caller treats 0 as a connection error of
 * type QPACK_ENCODER_STREAM_ERROR. */
int qpack_capacity_within_limit(u64 capacity, u64 max_table_capacity);
 
#endif