http3.c

Go to the documentation of this file.

#include "http3.h"
#include "server_internal.h"
 
#include <ascii-chat/common.h>
#include <string.h>
 
#define H3_MAX_HEADER_BYTES 16384U
#define H3_MAX_ORIGIN 512U
#define H3_MAX_PATH 512U
#define H3_SETTINGS_BUFFER 96U
#define H3_MAX_HEADERS 64U
#define H3_MAX_TEXT 2048U
 
typedef struct http3_stream_state http3_stream_state_t;

struct http_server_http3 {
  nghttp3_conn *http;
  int64_t control, request;
  char origin[H3_MAX_ORIGIN], path[H3_MAX_PATH];
  uint8_t settings[H3_SETTINGS_BUFFER];
  size_t settings_length, settings_written, settings_acked, header_bytes;
  int64_t pending_stream;
  size_t pending_bytes;
  bool pending;
  bool settings_received, headers_done, responded, accepted, malformed;
  bool method, scheme, authority, protocol, request_path, request_origin;
  http_server_t *http_server;
  char peer_address[64];
  char method_text[32], request_target[H3_MAX_TEXT];
  char header_names[H3_MAX_HEADERS][H3_MAX_TEXT], header_values[H3_MAX_HEADERS][H3_MAX_TEXT];
  http_header_t headers[H3_MAX_HEADERS];
  size_t header_count;
  uint8_t *request_body;
  size_t request_body_length, request_body_capacity;
  bool request_end_stream;
  uint8_t *response_body;
  size_t response_length, response_offset;
  http3_stream_state_t *streams;
};
 
struct http3_stream_state {
  http_server_http3_t *owner;
  int64_t stream_id;
  bool headers_done, responded, malformed;
  bool method, scheme, authority, protocol, request_path, request_origin;
  char method_text[32], request_target[H3_MAX_TEXT];
  char header_names[H3_MAX_HEADERS][H3_MAX_TEXT], header_values[H3_MAX_HEADERS][H3_MAX_TEXT];
  http_header_t headers[H3_MAX_HEADERS];
  size_t header_count, header_bytes;
  uint8_t *request_body;
  size_t request_body_length, request_body_capacity;
  bool request_end_stream;
  uint8_t *response_body;
  size_t response_length, response_offset;
  http3_stream_state_t *next;
};
 
#define H3_FIELD(server, state, field) ((state) ? (state)->field : (server)->field)
#define H3_PTR(server, state, field) ((state) ? &(state)->field : &(server)->field)
 
static bool equal_bytes(nghttp3_vec bytes, const char *value) {
  size_t length = strlen(value);
  return bytes.len == length && memcmp(bytes.base, value, length) == 0;
}
 
static uint8_t *put_varint(uint8_t *p, uint64_t value) {
  size_t length = value < (1ULL << 6) ? 1 : value < (1ULL << 14) ? 2 : value < (1ULL << 30) ? 4 : 8;
  for (size_t i = 0; i < length; ++i)
    p[length - i - 1] = (uint8_t)(value >> (8 * i));
  p[0] |= length == 1 ? 0 : length == 2 ? 0x40 : length == 4 ? 0x80 : 0xc0;
  return p + length;
}
 
static void make_settings(http_server_http3_t *server) {
  uint8_t body[H3_SETTINGS_BUFFER];
  uint8_t *p = body;
  /* QPACK is static-only. Advertise HTTP datagrams, extended CONNECT, and
   * browser WebTransport draft settings absent from nghttp3's settings API. */
  static const uint64_t entries[][2] = {{1, 0},        {6, H3_MAX_HEADER_BYTES}, {7, 0},         {8, 1}, {0x33, 1},
                                        {0xffd277, 1}, {0x2b603742, 1},          {0xc671706a, 1}};
  for (size_t i = 0; i < sizeof(entries) / sizeof(entries[0]); ++i) {
    p = put_varint(p, entries[i][0]);
    p = put_varint(p, entries[i][1]);
  }
  uint8_t *out = server->settings;
  out = put_varint(out, 0); /* HTTP/3 control stream */
  out = put_varint(out, 4); /* SETTINGS frame */
  out = put_varint(out, (uint64_t)(p - body));
  memcpy(out, body, (size_t)(p - body));
  server->settings_length = (size_t)(out - server->settings) + (size_t)(p - body);
}
 
static nghttp3_ssize keep_open(nghttp3_conn *conn, int64_t stream_id, nghttp3_vec *vec, size_t count, uint32_t *flags,
                               void *context, void *stream_context) {
  (void)conn;
  (void)stream_id;
  (void)vec;
  (void)count;
  (void)flags;
  (void)context;
  (void)stream_context;
  return NGHTTP3_ERR_WOULDBLOCK;
}
 
static nghttp3_ssize read_response_body(nghttp3_conn *conn, int64_t stream_id, nghttp3_vec *vec, size_t count,
                                        uint32_t *flags, void *context, void *stream_context) {
  (void)conn;
  (void)stream_id;
  http_server_http3_t *server = context;
  http3_stream_state_t *state = stream_context;
  size_t remaining = H3_FIELD(server, state, response_length) - H3_FIELD(server, state, response_offset);
  if (!count || !remaining)
    *flags |= NGHTTP3_DATA_FLAG_EOF;
  if (!remaining)
    return 0;
  vec[0].base = H3_FIELD(server, state, response_body) + H3_FIELD(server, state, response_offset);
  vec[0].len = remaining;
  *H3_PTR(server, state, response_offset) = H3_FIELD(server, state, response_length);
  *flags |= NGHTTP3_DATA_FLAG_EOF;
  return 1;
}
 
static asciichat_error_t http3_submit_response(void *context, unsigned status, const http_header_t *headers,
                                               size_t header_count, const void *body, size_t body_length) {
  http_server_http3_t *server = ((http3_stream_state_t *)context)->owner;
  http3_stream_state_t *state = context;
  if (!server || (state ? state->stream_id < 0 : server->request < 0) || status < 100 || status > 599 ||
      header_count > H3_MAX_HEADERS || body_length > http_server_max_response_body(server->http_server) ||
      (!body && body_length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 response");
  char status_text[4];
  safe_snprintf(status_text, sizeof(status_text), "%u", status);
  nghttp3_nv fields[H3_MAX_HEADERS + 1] = {
      {(uint8_t *)":status", (uint8_t *)status_text, sizeof(":status") - 1, strlen(status_text), NGHTTP3_NV_FLAG_NONE}};
  for (size_t i = 0; i < header_count; ++i) {
    if (!headers[i].name || !headers[i].value)
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 response header");
    fields[i + 1] = (nghttp3_nv){(uint8_t *)headers[i].name, (uint8_t *)headers[i].value, strlen(headers[i].name),
                                 strlen(headers[i].value), NGHTTP3_NV_FLAG_NONE};
  }
  SAFE_FREE(*H3_PTR(server, state, response_body));
  *H3_PTR(server, state, response_length) = body_length;
  *H3_PTR(server, state, response_offset) = 0;
  if (body_length) {
    *H3_PTR(server, state, response_body) = SAFE_MALLOC(body_length, uint8_t *);
    if (!H3_FIELD(server, state, response_body))
      return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP/3 response body");
    memcpy(H3_FIELD(server, state, response_body), body, body_length);
  }
  nghttp3_data_reader reader = {.read_data = read_response_body};
  int64_t stream_id = state ? state->stream_id : server->request;
  int result =
      nghttp3_conn_submit_response(server->http, stream_id, fields, header_count + 1, body_length ? &reader : NULL);
  if (result != 0) {
    SAFE_FREE(*H3_PTR(server, state, response_body));
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot submit HTTP/3 response: %s", nghttp3_strerror(result));
  }
  *H3_PTR(server, state, responded) = true;
  return ASCIICHAT_OK;
}
 
static int maybe_respond(http_server_http3_t *server) {
  if (!server->headers_done || !server->settings_received || server->responded)
    return 0;
  bool webtransport_connect = server->http_server && strcmp(server->method_text, "CONNECT") == 0 && server->protocol;
  if (server->http_server && !webtransport_connect)
    return 0;
  bool accepted = !server->malformed;
  accepted = accepted && server->method && server->scheme && server->authority;
  accepted = accepted && server->protocol && server->request_path && server->request_origin;
  static const uint8_t status_name[] = ":status", ok[] = "200", forbidden[] = "403";
  static const uint8_t draft_name[] = "sec-webtransport-http3-draft", draft_value[] = "draft02";
  nghttp3_nv fields[] = {
      {status_name, accepted ? ok : forbidden, sizeof(status_name) - 1, 3, NGHTTP3_NV_FLAG_NONE},
      {draft_name, draft_value, sizeof(draft_name) - 1, sizeof(draft_value) - 1, NGHTTP3_NV_FLAG_NONE}};
  const nghttp3_data_reader reader = {.read_data = keep_open};
  int result =
      nghttp3_conn_submit_response(server->http, server->request, fields, accepted ? 2 : 1, accepted ? &reader : NULL);
  if (result != 0)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  server->responded = true;
  server->accepted = accepted;
  return 0;
}
 
static int dispatch_generic_request(http_server_http3_t *server, http3_stream_state_t *state) {
  if (!state || !server->http_server || !state->headers_done || !server->settings_received ||
      !state->request_end_stream || state->responded)
    return 0;
  if (strcmp(state->method_text, "CONNECT") == 0 && state->protocol)
    return 0;
  asciichat_error_t result = http_server_dispatch_http3(
      server->http_server, state->method_text, state->request_target, state->headers, state->header_count,
      state->request_body, state->request_body_length, server->peer_address, http3_submit_response, state);
  return result == ASCIICHAT_OK ? 0 : NGHTTP3_ERR_CALLBACK_FAILURE;
}
 
static int receive_data(nghttp3_conn *conn, int64_t stream_id, const uint8_t *data, size_t length, void *context,
                        void *stream_context) {
  (void)conn;
  (void)stream_context;
  http_server_http3_t *server = context;
  http3_stream_state_t *state = stream_context;
  if (!server->http_server)
    return 0;
  if (!state || stream_id != state->stream_id || (!data && length))
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  size_t limit = http_server_max_request_body(server->http_server);
  if (length > limit || state->request_body_length > limit - length)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  if (length) {
    size_t required = state->request_body_length + length;
    if (required > state->request_body_capacity) {
      size_t capacity = state->request_body_capacity ? state->request_body_capacity : 4096;
      while (capacity < required) {
        if (capacity > SIZE_MAX / 2)
          capacity = required;
        else
          capacity *= 2;
      }
      uint8_t *body = SAFE_REALLOC(state->request_body, capacity, uint8_t *);
      if (!body)
        return NGHTTP3_ERR_NOMEM;
      state->request_body = body;
      state->request_body_capacity = capacity;
    }
    memcpy(state->request_body + state->request_body_length, data, length);
    state->request_body_length += length;
  }
  return 0;
}
 
static int end_stream(nghttp3_conn *conn, int64_t stream_id, void *context, void *stream_context) {
  (void)conn;
  (void)stream_context;
  http_server_http3_t *server = context;
  http3_stream_state_t *state = stream_context;
  if (!server->http_server)
    return 0;
  if (!state || stream_id != state->stream_id || state->request_end_stream)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  state->request_end_stream = true;
  return dispatch_generic_request(server, state);
}
 
static int begin_headers(nghttp3_conn *conn, int64_t stream_id, void *context, void *stream_context) {
  (void)conn;
  (void)stream_context;
  http_server_http3_t *server = context;
  if (stream_id < 0 || (stream_id & 3) != 0)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  if (!server->http_server)
    if (server->request != -1)
      return NGHTTP3_ERR_CALLBACK_FAILURE;
  if (server->http_server) {
    http3_stream_state_t *state = SAFE_CALLOC(1, sizeof(*state), http3_stream_state_t *);
    if (!state)
      return NGHTTP3_ERR_NOMEM;
    state->owner = server;
    state->stream_id = stream_id;
    state->next = server->streams;
    server->streams = state;
    if (nghttp3_conn_set_stream_user_data(conn, stream_id, state) != 0) {
      server->streams = state->next;
      SAFE_FREE(state);
      return NGHTTP3_ERR_CALLBACK_FAILURE;
    }
  } else
    server->request = stream_id;
  return 0;
}
 
static int receive_header(nghttp3_conn *conn, int64_t stream_id, int32_t token, nghttp3_rcbuf *name,
                          nghttp3_rcbuf *value, uint8_t flags, void *context, void *stream_context) {
  (void)conn;
  (void)token;
  (void)flags;
  (void)stream_context;
  http_server_http3_t *server = context;
  http3_stream_state_t *state = stream_context;
  if (server->http_server && !state)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  nghttp3_vec key = nghttp3_rcbuf_get_buf(name), val = nghttp3_rcbuf_get_buf(value);
  if (stream_id != (state ? state->stream_id : server->request) ||
      key.len > H3_MAX_HEADER_BYTES - H3_FIELD(server, state, header_bytes) ||
      val.len > H3_MAX_HEADER_BYTES - H3_FIELD(server, state, header_bytes) - key.len)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  *H3_PTR(server, state, header_bytes) += key.len + val.len;
  if (key.len >= H3_MAX_TEXT || val.len >= H3_MAX_TEXT || H3_FIELD(server, state, header_count) >= H3_MAX_HEADERS)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  size_t index = H3_FIELD(server, state, header_count);
  memcpy(H3_FIELD(server, state, header_names)[index], key.base, key.len);
  H3_FIELD(server, state, header_names)[index][key.len] = 0;
  memcpy(H3_FIELD(server, state, header_values)[index], val.base, val.len);
  H3_FIELD(server, state, header_values)[index][val.len] = 0;
  H3_FIELD(server, state, headers)
  [index] =
      (http_header_t){H3_FIELD(server, state, header_names)[index], H3_FIELD(server, state, header_values)[index]};
  (*H3_PTR(server, state, header_count))++;
  if (equal_bytes(key, ":method")) {
    if (val.len >= sizeof(H3_FIELD(server, state, method_text)))
      return NGHTTP3_ERR_CALLBACK_FAILURE;
    memcpy(H3_FIELD(server, state, method_text), val.base, val.len);
    H3_FIELD(server, state, method_text)[val.len] = 0;
  } else if (equal_bytes(key, ":path")) {
    if (val.len >= sizeof(H3_FIELD(server, state, request_target)))
      return NGHTTP3_ERR_CALLBACK_FAILURE;
    memcpy(H3_FIELD(server, state, request_target), val.base, val.len);
    H3_FIELD(server, state, request_target)[val.len] = 0;
  }
  bool *field = NULL, valid = false;
  if (equal_bytes(key, ":method")) {
    field = &server->method;
    valid = server->http_server ? val.len > 0 : equal_bytes(val, "CONNECT");
  } else if (equal_bytes(key, ":scheme")) {
    field = &server->scheme;
    valid = equal_bytes(val, "https");
  } else if (equal_bytes(key, ":authority")) {
    field = &server->authority;
    valid = val.len > 0;
  } else if (equal_bytes(key, ":protocol")) {
    field = &server->protocol;
    valid = equal_bytes(val, "webtransport");
  } else if (equal_bytes(key, ":path")) {
    field = &server->request_path;
    valid = server->http_server ? val.len > 0 : equal_bytes(val, server->path);
  } else if (equal_bytes(key, "origin")) {
    field = &server->request_origin;
    valid = server->http_server ? true : equal_bytes(val, server->origin);
  }
  if (field && !state) {
    if (*field || !valid)
      server->malformed = true;
    *field = true;
  } else if (field) {
    bool *stream_field = NULL;
    if (equal_bytes(key, ":method"))
      stream_field = &state->method;
    else if (equal_bytes(key, ":scheme"))
      stream_field = &state->scheme;
    else if (equal_bytes(key, ":authority"))
      stream_field = &state->authority;
    else if (equal_bytes(key, ":protocol"))
      stream_field = &state->protocol;
    else if (equal_bytes(key, ":path"))
      stream_field = &state->request_path;
    else if (equal_bytes(key, "origin"))
      stream_field = &state->request_origin;
    if (*stream_field || !valid)
      state->malformed = true;
    *stream_field = true;
  }
  return 0;
}
 
static int end_headers(nghttp3_conn *conn, int64_t stream_id, int fin, void *context, void *stream_context) {
  (void)conn;
  (void)stream_context;
  http_server_http3_t *server = context;
  http3_stream_state_t *state = stream_context;
  if (stream_id != (state ? state->stream_id : server->request) || H3_FIELD(server, state, headers_done))
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  *H3_PTR(server, state, headers_done) = true;
  if (server->http_server && state)
    return 0;
  server->malformed |= fin != 0;
  return maybe_respond(server);
}
 
static int receive_settings(nghttp3_conn *conn, const nghttp3_proto_settings *settings, void *context) {
  (void)conn;
  http_server_http3_t *server = context;
  if (!server->http_server && !settings->h3_datagram)
    return NGHTTP3_ERR_CALLBACK_FAILURE;
  server->settings_received = true;
  if (server->http_server)
    return 0;
  return maybe_respond(server);
}
 
static int close_stream(nghttp3_conn *conn, int64_t stream_id, uint64_t app_error_code, void *context,
                        void *stream_context) {
  (void)conn;
  (void)app_error_code;
  http_server_http3_t *server = context;
  http3_stream_state_t *state = stream_context;
  if (!server || !state || state->stream_id != stream_id)
    return 0;
  http_server_invalidate_http3_context(server->http_server, state);
  http3_stream_state_t **cursor = &server->streams;
  while (*cursor && *cursor != state)
    cursor = &(*cursor)->next;
  if (*cursor == state)
    *cursor = state->next;
  SAFE_FREE(state->request_body);
  SAFE_FREE(state->response_body);
  SAFE_FREE(state);
  return 0;
}
 
asciichat_error_t http_server_http3_create(const char *origin, const char *path, int64_t control, int64_t encoder,
                                           int64_t decoder, http_server_t *http_server, const char *peer_address,
                                           http_server_http3_t **out) {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing HTTP/3 server output");
  *out = NULL;
  if ((!http_server && (!origin || !path)) ||
      (origin && strnlen(origin, sizeof(((http_server_http3_t *)0)->origin)) >= H3_MAX_ORIGIN) ||
      (path && strnlen(path, sizeof(((http_server_http3_t *)0)->path)) >= H3_MAX_PATH) ||
      (!http_server && (strncmp(origin, "https://", sizeof("https://") - 1) || path[0] != '/')) || control < 0 ||
      encoder < 0 || decoder < 0 || control == encoder || control == decoder || encoder == decoder ||
      (control & 3) != 3 || (encoder & 3) != 3 || (decoder & 3) != 3)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 WebTransport configuration");
  http_server_http3_t *server = SAFE_CALLOC(1, sizeof(*server), http_server_http3_t *);
  if (!server)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP/3 server");
  if (origin)
    memcpy(server->origin, origin, strlen(origin) + (size_t)1);
  if (path)
    memcpy(server->path, path, strlen(path) + (size_t)1);
  server->control = control;
  server->http_server = http_server;
  safe_snprintf(server->peer_address, sizeof(server->peer_address), "%s", peer_address ? peer_address : "unknown");
  server->request = -1;
  make_settings(server);
  nghttp3_callbacks callbacks = {.stream_close = close_stream,
                                 .begin_headers = begin_headers,
                                 .recv_header = receive_header,
                                 .end_headers = end_headers,
                                 .recv_data = receive_data,
                                 .end_stream = end_stream,
                                 .recv_settings2 = receive_settings};
  nghttp3_settings settings;
  nghttp3_settings_default(&settings);
  settings.enable_connect_protocol = 1;
  settings.h3_datagram = 1;
  settings.qpack_max_dtable_capacity = 0;
  settings.qpack_encoder_max_dtable_capacity = 0;
  settings.qpack_blocked_streams = 0;
  settings.max_field_section_size = H3_MAX_HEADER_BYTES;
  int result = nghttp3_conn_server_new(&server->http, &callbacks, &settings, NULL, server);
  if (!result)
    result = nghttp3_conn_bind_control_stream(server->http, control);
  if (!result)
    result = nghttp3_conn_bind_qpack_streams(server->http, encoder, decoder);
  if (result) {
    http_server_http3_destroy(&server);
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot initialize HTTP/3: %s", nghttp3_strerror(result));
  }
  nghttp3_conn_set_max_client_streams_bidi(server->http, 128);
  *out = server;
  return ASCIICHAT_OK;
}
 
asciichat_error_t http_server_http3_read(http_server_http3_t *server, int64_t stream_id, const uint8_t *data,
                                         size_t length, bool fin, uint64_t now_ns, size_t *consumed) {
  if (!server || !consumed || (!data && length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 input");
  *consumed = 0;
  nghttp3_ssize result = nghttp3_conn_read_stream2(server->http, stream_id, data, length, fin, now_ns);
  if (result < 0)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "HTTP/3 receive failed: %s", nghttp3_strerror((int)result));
  *consumed = (size_t)result;
  return ASCIICHAT_OK;
}
 
asciichat_error_t http_server_http3_write(http_server_http3_t *server, int64_t *stream_id, bool *fin,
                                          nghttp3_vec *vectors, size_t capacity, size_t *count) {
  if (!server || !stream_id || !fin || !vectors || !capacity || !count)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 output");
  if (server->pending)
    return SET_ERRNO(ERROR_INVALID_STATE, "HTTP/3 output has not been submitted");
  *stream_id = -1;
  *fin = false;
  *count = 0;
  if (server->settings_written < server->settings_length) {
    *stream_id = server->control;
    vectors[0].base = server->settings + server->settings_written;
    vectors[0].len = server->settings_length - server->settings_written;
    *count = 1;
    server->pending = true;
    server->pending_stream = *stream_id;
    server->pending_bytes = vectors[0].len;
    return ASCIICHAT_OK;
  }
  for (;;) {
    int is_fin = 0;
    nghttp3_ssize result = nghttp3_conn_writev_stream(server->http, stream_id, &is_fin, vectors, capacity);
    if (result < 0)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "HTTP/3 output failed: %s", nghttp3_strerror((int)result));
    if (*stream_id != server->control) {
      *fin = is_fin != 0;
      *count = (size_t)result;
      if (*stream_id >= 0) {
        server->pending = true;
        server->pending_stream = *stream_id;
        server->pending_bytes = 0;
        for (nghttp3_ssize i = 0; i < result; ++i) {
          if (vectors[i].len > SIZE_MAX - server->pending_bytes)
            return SET_ERRNO(ERROR_NETWORK_SIZE, "HTTP/3 output size overflow");
          server->pending_bytes += vectors[i].len;
        }
      }
      return ASCIICHAT_OK;
    }
    size_t skipped = 0;
    for (nghttp3_ssize i = 0; i < result; ++i)
      skipped += vectors[i].len;
    if (is_fin || !skipped || nghttp3_conn_add_write_offset(server->http, *stream_id, skipped) ||
        nghttp3_conn_add_ack_offset(server->http, *stream_id, skipped))
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot replace HTTP/3 control settings");
  }
}
 
asciichat_error_t http_server_http3_wrote(http_server_http3_t *server, int64_t stream_id, size_t length) {
  if (!server || !server->pending || stream_id != server->pending_stream || length > server->pending_bytes)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 submitted output");
  if (stream_id == server->control) {
    server->settings_written += length;
    server->pending = false;
    return ASCIICHAT_OK;
  }
  int result = nghttp3_conn_add_write_offset(server->http, stream_id, length);
  if (result)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot advance HTTP/3 output: %s", nghttp3_strerror(result));
  server->pending = false;
  return ASCIICHAT_OK;
}
 
asciichat_error_t http_server_http3_ack(http_server_http3_t *server, int64_t stream_id, uint64_t length) {
  if (!server)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 server");
  if (stream_id == server->control) {
    if (length > server->settings_written - server->settings_acked)
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/3 settings acknowledgement");
    server->settings_acked += (size_t)length;
    return ASCIICHAT_OK;
  }
  int result = nghttp3_conn_add_ack_offset(server->http, stream_id, length);
  return result ? SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot acknowledge HTTP/3 output: %s", nghttp3_strerror(result))
                : ASCIICHAT_OK;
}
 
bool http_server_http3_accepted(const http_server_http3_t *server, int64_t *session_id) {
  if (!server || !server->accepted)
    return false;
  if (session_id)
    *session_id = server->request;
  return true;
}
 
void http_server_http3_destroy(http_server_http3_t **server) {
  if (!server || !*server)
    return;
  http_server_invalidate_http3_context((*server)->http_server, *server);
  nghttp3_conn_del((*server)->http);
  while ((*server)->streams) {
    http3_stream_state_t *state = (*server)->streams;
    (*server)->streams = state->next;
    SAFE_FREE(state->request_body);
    SAFE_FREE(state->response_body);
    SAFE_FREE(state);
  }
  SAFE_FREE((*server)->request_body);
  SAFE_FREE((*server)->response_body);
  SAFE_FREE(*server);
}