datagram.h File Reference

Go to the source code of this file.

Data Structures
struct	quic_datagram_slot_t
struct	quic_datagram_reader_t
	acip quic datagram slot keeps the values that move through the subsystem: data, received, cost, id. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself. More...

Macros
#define	QUIC_DATAGRAM_HEADER_SIZE   28U
#define	QUIC_DATAGRAM_MAX_FRAGMENTS   4096U
#define	QUIC_DATAGRAM_SLOTS   8U
#define	QUIC_DATAGRAM_BUDGET   (4U * 1024U * 1024U)
#define	QUIC_DATAGRAM_EXPIRY_NS   UINT64_C(1000000000)

Functions
asciichat_error_t	quic_datagram_fragment (acip_traffic_class_t traffic_class, uint64_t id, const void *packet, size_t length, uint16_t unit, uint16_t index, void *out, size_t capacity, size_t *out_length)
asciichat_error_t	quic_datagram_read (quic_datagram_reader_t *reader, const void *data, size_t length, uint64_t now_ns, acip_traffic_class_t *traffic_class, uint8_t **out, size_t *out_length)
void	quic_datagram_expire (quic_datagram_reader_t *reader, uint64_t now_ns)
void	quic_datagram_reset (quic_datagram_reader_t *reader)

Macro Definition Documentation

QUIC_DATAGRAM_BUDGET

#define QUIC_DATAGRAM_BUDGET   (4U * 1024U * 1024U)

Definition at line 14 of file datagram.h.

QUIC_DATAGRAM_EXPIRY_NS

#define QUIC_DATAGRAM_EXPIRY_NS   UINT64_C(1000000000)

Definition at line 15 of file datagram.h.

Referenced by quic_connection_expiry(), and quic_datagram_expire().

QUIC_DATAGRAM_HEADER_SIZE

#define QUIC_DATAGRAM_HEADER_SIZE   28U

Definition at line 11 of file datagram.h.

Referenced by quic_connection_datagram_payload(), quic_datagram_fragment(), and quic_datagram_read().

QUIC_DATAGRAM_MAX_FRAGMENTS

#define QUIC_DATAGRAM_MAX_FRAGMENTS   4096U

Definition at line 12 of file datagram.h.

Referenced by quic_connection_submit_datagram(), quic_datagram_fragment(), and quic_datagram_read().

QUIC_DATAGRAM_SLOTS

#define QUIC_DATAGRAM_SLOTS   8U

Definition at line 13 of file datagram.h.

Referenced by quic_connection_expiry(), quic_datagram_expire(), and quic_datagram_reset().

Function Documentation

quic_datagram_expire()

void quic_datagram_expire	(	quic_datagram_reader_t *	reader,
		uint64_t	now_ns )

Definition at line 85 of file datagram.c.

                                                                           {
  if (!reader || now_ns < reader->last_time_ns)
    return;
  reader->last_time_ns = now_ns;
  for (size_t i = 0; i < QUIC_DATAGRAM_SLOTS; ++i) {
    quic_datagram_slot_t *slot = &reader->slots[i];
    if (slot->data && now_ns - slot->started_ns >= QUIC_DATAGRAM_EXPIRY_NS)
      clear_slot(reader, slot);
  }
}

References quic_datagram_slot_t::data, quic_datagram_reader_t::last_time_ns, QUIC_DATAGRAM_EXPIRY_NS, QUIC_DATAGRAM_SLOTS, quic_datagram_reader_t::slots, and quic_datagram_slot_t::started_ns.

Referenced by quic_datagram_read().

quic_datagram_fragment()

asciichat_error_t quic_datagram_fragment	(	acip_traffic_class_t	traffic_class,
		uint64_t	id,
		const void *	packet,
		size_t	length,
		uint16_t	unit,
		uint16_t	index,
		void *	out,
		size_t	capacity,
		size_t *	out_length )

Definition at line 45 of file datagram.c.

                                                             {
  if (!out_length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC datagram output length");
  *out_length = 0;
  if (!media_flow(flow) || !id || !packet || !length || length > MAX_WIRE_PACKET || !unit || !out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC datagram fragment parameters");
  size_t count = (length + unit - 1) / unit;
  if (count > QUIC_DATAGRAM_MAX_FRAGMENTS || index >= count)
    return SET_ERRNO(ERROR_NETWORK_SIZE, "Invalid QUIC datagram fragment count or index");
  size_t offset = (size_t)index * unit;
  size_t part = length - offset < unit ? length - offset : unit;
  if (capacity < QUIC_DATAGRAM_HEADER_SIZE + part)
    return SET_ERRNO(ERROR_BUFFER_FULL, "QUIC datagram output buffer is too small");
  uint8_t *wire = out;
  memcpy(wire, "ACQD", sizeof("ACQD") - 1);
  wire[4] = 1;
  wire[5] = (uint8_t)flow;
  wire[6] = wire[7] = 0;
  put64(wire + 8, id);
  put32(wire + 16, (uint32_t)length);
  put16(wire + 20, unit);
  put16(wire + 22, index);
  put16(wire + 24, (uint16_t)count);
  wire[26] = wire[27] = 0;
  memcpy(wire + QUIC_DATAGRAM_HEADER_SIZE, (const uint8_t *)packet + offset, part);
  *out_length = QUIC_DATAGRAM_HEADER_SIZE + part;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_BUFFER_FULL, ERROR_INVALID_PARAM, ERROR_NETWORK_SIZE, index, MAX_WIRE_PACKET, out, QUIC_DATAGRAM_HEADER_SIZE, QUIC_DATAGRAM_MAX_FRAGMENTS, and SET_ERRNO.

quic_datagram_read()

asciichat_error_t quic_datagram_read	(	quic_datagram_reader_t *	reader,
		const void *	data,
		size_t	length,
		uint64_t	now_ns,
		acip_traffic_class_t *	traffic_class,
		uint8_t **	out,
		size_t *	out_length )

Definition at line 104 of file datagram.c.

                                                                                                        {
  if (!out || !out_length || !flow_out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC datagram output");
  *out = NULL;
  *out_length = 0;
  if (!reader || !data || length < QUIC_DATAGRAM_HEADER_SIZE || now_ns < reader->last_time_ns)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC datagram input");
  const uint8_t *wire = data;
  acip_traffic_class_t flow = (acip_traffic_class_t)wire[5];
  uint64_t id = get64(wire + 8);
  uint32_t total = get32(wire + 16);
  uint16_t unit = get16(wire + 20), index = get16(wire + 22), count = get16(wire + 24);
  if (memcmp(wire, "ACQD", sizeof("ACQD") - 1) || wire[4] != 1 || !media_flow(flow) || wire[6] || wire[7] || wire[26] ||
      wire[27] || !id || !total || total > MAX_WIRE_PACKET || !unit || !count || count > QUIC_DATAGRAM_MAX_FRAGMENTS ||
      count != ((size_t)total + unit - 1) / unit || index >= count)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid QUIC datagram envelope");
  size_t offset = (size_t)index * unit;
  size_t part = total - offset < unit ? total - offset : unit;
  if (length != QUIC_DATAGRAM_HEADER_SIZE + part)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid QUIC datagram fragment size");
  quic_datagram_expire(reader, now_ns);
  size_t first = flow == ACIP_TRAFFIC_AUDIO ? 0 : FLOW_SLOTS;
  quic_datagram_slot_t *slot = NULL, *empty = NULL;
  size_t flow_bytes = 0;
  for (size_t i = first; i < first + FLOW_SLOTS; ++i) {
    quic_datagram_slot_t *candidate = &reader->slots[i];
    flow_bytes += candidate->cost;
    if (candidate->data && candidate->id == id)
      slot = candidate;
    else if (!candidate->data && !empty)
      empty = candidate;
  }
  if (slot && (slot->total != total || slot->unit != unit || slot->count != count))
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Conflicting QUIC datagram fragments");
  if (!slot) {
    if (!empty || total > FLOW_BUDGET - flow_bytes)
      return SET_ERRNO(ERROR_BUFFER_FULL, "QUIC datagram reassembly budget exhausted");
    size_t bitmap_size = (count + 7U) / 8U;
    uint8_t *packet = buffer_alloc(NULL, total);
    uint8_t *bitmap = buffer_alloc(NULL, bitmap_size);
    if (!packet || !bitmap) {
      buffer_release(packet);
      buffer_release(bitmap);
      return SET_ERRNO(ERROR_MEMORY, "Cannot allocate QUIC datagram reassembly");
    }
    size_t cost = buffer_capacity(packet) + buffer_capacity(bitmap);
    if (cost > FLOW_BUDGET - flow_bytes) {
      buffer_release(packet);
      buffer_release(bitmap);
      return SET_ERRNO(ERROR_BUFFER_FULL, "QUIC datagram reassembly budget exhausted");
    }
    memset(bitmap, 0, bitmap_size);
    *empty = (quic_datagram_slot_t){.data = packet,
                                    .received = bitmap,
                                    .cost = cost,
                                    .id = id,
                                    .started_ns = now_ns,
                                    .total = total,
                                    .unit = unit,
                                    .count = count,
                                    .traffic_class = flow};
    reader->bytes += cost;
    slot = empty;
  }
  uint8_t mask = (uint8_t)(1U << (index % 8));
  if (slot->received[index / 8] & mask) {
    if (memcmp(slot->data + offset, wire + QUIC_DATAGRAM_HEADER_SIZE, part))
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Conflicting duplicate QUIC datagram fragment");
    return ASCIICHAT_OK;
  }
  memcpy(slot->data + offset, wire + QUIC_DATAGRAM_HEADER_SIZE, part);
  slot->received[index / 8] |= mask;
  if (++slot->received_count == slot->count) {
    *out = slot->data;
    *out_length = slot->total;
    *flow_out = flow;
    slot->data = NULL;
    reader->bytes -= slot->cost;
    buffer_release(slot->received);
    memset(slot, 0, sizeof(*slot));
  }
  return ASCIICHAT_OK;
}

References ACIP_TRAFFIC_AUDIO, ASCIICHAT_OK, buffer_alloc(), buffer_capacity(), buffer_release, quic_datagram_reader_t::bytes, quic_datagram_slot_t::cost, quic_datagram_slot_t::count, quic_datagram_slot_t::data, ERROR_BUFFER_FULL, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK_PROTOCOL, FLOW_BUDGET, FLOW_SLOTS, quic_datagram_slot_t::id, index, MAX_WIRE_PACKET, out, quic_datagram_expire(), QUIC_DATAGRAM_HEADER_SIZE, QUIC_DATAGRAM_MAX_FRAGMENTS, quic_datagram_slot_t::received, quic_datagram_slot_t::received_count, SET_ERRNO, quic_datagram_reader_t::slots, quic_datagram_slot_t::total, and quic_datagram_slot_t::unit.

quic_datagram_reset()

void quic_datagram_reset

(

quic_datagram_reader_t *

reader

)

Definition at line 96 of file datagram.c.

                                                         {
  if (!reader)
    return;
  for (size_t i = 0; i < QUIC_DATAGRAM_SLOTS; ++i)
    clear_slot(reader, &reader->slots[i]);
  memset(reader, 0, sizeof(*reader));
}

References QUIC_DATAGRAM_SLOTS, and quic_datagram_reader_t::slots.

Referenced by quic_connection_destroy().