http3.h File Reference

Go to the source code of this file.

Typedefs
typedef struct http_server_http3	http_server_http3_t

Functions
asciichat_error_t	http_server_http3_create (const char *origin, const char *path, int64_t control_stream, int64_t encoder_stream, int64_t decoder_stream, http_server_t *http_server, const char *peer_address, http_server_http3_t **out)
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)
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)
asciichat_error_t	http_server_http3_wrote (http_server_http3_t *server, int64_t stream_id, size_t length)
asciichat_error_t	http_server_http3_ack (http_server_http3_t *server, int64_t stream_id, uint64_t length)
bool	http_server_http3_accepted (const http_server_http3_t *server, int64_t *session_id)
void	http_server_http3_destroy (http_server_http3_t **server)

Typedef Documentation

http_server_http3_t

typedef struct http_server_http3 http_server_http3_t

Definition at line 11 of file http3.h.

Function Documentation

http_server_http3_accepted()

bool http_server_http3_accepted	(	const http_server_http3_t *	server,
		int64_t *	session_id )

Definition at line 549 of file http3.c.

                                                                                        {
  if (!server || !server->accepted)
    return false;
  if (session_id)
    *session_id = server->request;
  return true;
}

References http_server_http3::accepted, http_server_http3::request, and session_id.

Referenced by quic_connection_datagram_payload(), and quic_connection_webtransport_ready().

http_server_http3_ack()

asciichat_error_t http_server_http3_ack	(	http_server_http3_t *	server,
		int64_t	stream_id,
		uint64_t	length )

Definition at line 535 of file http3.c.

                                                                                                         {
  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;
}

References ASCIICHAT_OK, http_server_http3::control, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, http_server_http3::http, SET_ERRNO, http_server_http3::settings_acked, and http_server_http3::settings_written.

http_server_http3_create()

asciichat_error_t http_server_http3_create	(	const char *	origin,
		const char *	path,
		int64_t	control_stream,
		int64_t	encoder_stream,
		int64_t	decoder_stream,
		http_server_t *	http_server,
		const char *	peer_address,
		http_server_http3_t **	out )

Definition at line 406 of file http3.c.

                                                                      {
  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;
}

References ASCIICHAT_OK, http_server_http3::control, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK_PROTOCOL, H3_MAX_HEADER_BYTES, H3_MAX_ORIGIN, H3_MAX_PATH, http_server_http3::http, http_server_http3::http_server, http_server_http3_destroy(), http_server_http3::origin, out, http_server_http3::path, http_server_http3::peer_address, http_server_http3::request, SAFE_CALLOC, safe_snprintf(), and SET_ERRNO.

http_server_http3_destroy()

void http_server_http3_destroy

(

http_server_http3_t **

server

)

Definition at line 557 of file http3.c.

                                                             {
  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);
}

References http_server_invalidate_http3_context(), and SAFE_FREE.

Referenced by http_server_http3_create(), and quic_connection_destroy().

http_server_http3_read()

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 )

Definition at line 460 of file http3.c.

                                                                                                     {
  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;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, http_server_http3::http, and SET_ERRNO.

http_server_http3_write()

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 )

Definition at line 472 of file http3.c.

                                                                                                {
  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");
  }
}

References ASCIICHAT_OK, http_server_http3::control, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK_PROTOCOL, ERROR_NETWORK_SIZE, http_server_http3::http, http_server_http3::pending, http_server_http3::pending_bytes, http_server_http3::pending_stream, SET_ERRNO, http_server_http3::settings, http_server_http3::settings_length, and http_server_http3::settings_written.

http_server_http3_wrote()

asciichat_error_t http_server_http3_wrote	(	http_server_http3_t *	server,
		int64_t	stream_id,
		size_t	length )

Definition at line 520 of file http3.c.

                                                                                                         {
  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;
}

References ASCIICHAT_OK, http_server_http3::control, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, http_server_http3::http, http_server_http3::pending, http_server_http3::pending_bytes, http_server_http3::pending_stream, SET_ERRNO, and http_server_http3::settings_written.