connection.c File Reference

Go to the source code of this file.

Data Structures
struct	send_chunk
struct	send_stream_t
struct	receive_stream_t
struct	http3_receive_stream_t
struct	datagram_send
struct	quic_connection
	This is the handoff point for receive stream. Callers fill id, received_offset, reader, active before passing it on; consumers read the values during the operation and return ownership only where the member contract explicitly says they do. More...
struct	receive_context_t

Macros
#define	QUIC_CONNECTION_ID_LENGTH   16
#define	QUIC_INITIAL_STREAM_WINDOW   (5U * 1024U * 1024U)
#define	QUIC_INITIAL_CONNECTION_WINDOW   (16U * 1024U * 1024U)
#define	QUIC_IDLE_TIMEOUT_NS   (30ULL * 1000000000ULL)
#define	QUIC_FLOW_COUNT   3
#define	QUIC_DATAGRAM_FRAME_LIMIT   1400U
#define	QUIC_DATAGRAM_OVERHEAD   128U
#define	QUIC_HTTP3_PEER_UNI_STREAMS   6U

Typedefs
typedef struct send_chunk	send_chunk_t
typedef struct datagram_send	datagram_send_t

Functions
asciichat_error_t	quic_connection_client_create (quic_tls_t *tls, const char *server_name, const ngtcp2_path *path, uint64_t now_ns, quic_connection_t **out)
asciichat_error_t	quic_connection_server_create (quic_tls_t *tls, const ngtcp2_path *path, const void *initial, size_t initial_length, uint64_t now_ns, quic_connection_t **out)
asciichat_error_t	quic_connection_server_create_validated (quic_tls_t *tls, const ngtcp2_path *path, const void *initial, size_t initial_length, const ngtcp2_cid *original_dcid, uint64_t now_ns, quic_connection_t **out)
asciichat_error_t	quic_connection_matches_cid (const quic_connection_t *connection, const uint8_t *cid, size_t length, bool *matches)
asciichat_error_t	quic_connection_set_receiver (quic_connection_t *connection, quic_stream_emit_fn emit, void *context)
asciichat_error_t	quic_connection_clear_receiver (quic_connection_t *connection, void *context)
void	quic_connection_set_keyframe_notifier (quic_connection_t *connection, void(*notify)(uint16_t, uint32_t, void *), void *context)
void	quic_connection_set_security_notifier (quic_connection_t *connection, void(*notify)(void *), void *context)
asciichat_error_t	quic_connection_allow_media (quic_connection_t *connection)
asciichat_error_t	quic_connection_enable_security (quic_connection_t *connection, crypto_context_t *crypto)
bool	quic_connection_security_ready (const quic_connection_t *connection)
size_t	quic_connection_datagram_payload (const quic_connection_t *connection)
asciichat_error_t	quic_connection_validate_datagram (const quic_connection_t *connection, acip_traffic_class_t flow, uint64_t deadline_ns)
asciichat_error_t	quic_connection_submit_datagram (quic_connection_t *connection, acip_traffic_class_t flow, const void *packet, size_t length, uint64_t deadline_ns)
asciichat_error_t	quic_connection_submit (quic_connection_t *connection, acip_traffic_class_t traffic_class, const void *packet, size_t length)
size_t	quic_connection_pending_bytes (const quic_connection_t *connection)
asciichat_error_t	quic_connection_finish_stream (quic_connection_t *connection, acip_traffic_class_t traffic_class)
bool	quic_connection_received_fin (const quic_connection_t *connection, acip_traffic_class_t traffic_class)
asciichat_error_t	quic_connection_receive (quic_connection_t *connection, const ngtcp2_path *path, const void *packet, size_t length, uint64_t now_ns)
bool	quic_connection_pending_packet_class (const quic_connection_t *connection, acip_traffic_class_t *traffic_class)
asciichat_error_t	quic_connection_write_close (quic_connection_t *connection, ngtcp2_path_storage *path, void *packet, size_t capacity, size_t *length, uint64_t now_ns)
asciichat_error_t	quic_connection_write (quic_connection_t *connection, ngtcp2_path_storage *path, void *packet, size_t capacity, size_t *length, uint64_t now_ns)
asciichat_error_t	quic_connection_packet_sent (quic_connection_t *connection, uint64_t now_ns)
uint64_t	quic_connection_expiry (const quic_connection_t *connection)
asciichat_error_t	quic_connection_handle_expiry (quic_connection_t *connection, uint64_t now_ns)
bool	quic_connection_accept_ready (const quic_connection_t *connection)
bool	quic_connection_webtransport_ready (const quic_connection_t *connection)
bool	quic_connection_tls_ready (const quic_connection_t *connection)
asciichat_error_t	quic_connection_peer_address (const quic_connection_t *connection, struct sockaddr_storage *address, socklen_t *length)
void	quic_connection_destroy (quic_connection_t **connection)
asciichat_error_t	quic_connection_migrate (quic_connection_t *connection, const struct sockaddr *local, socklen_t length, uint64_t now_ns)

Macro Definition Documentation

QUIC_CONNECTION_ID_LENGTH

#define QUIC_CONNECTION_ID_LENGTH   16

Definition at line 16 of file lib/network/quic/connection.c.

QUIC_DATAGRAM_FRAME_LIMIT

#define QUIC_DATAGRAM_FRAME_LIMIT   1400U

Definition at line 21 of file lib/network/quic/connection.c.

Referenced by quic_connection_datagram_payload().

QUIC_DATAGRAM_OVERHEAD

#define QUIC_DATAGRAM_OVERHEAD   128U

Definition at line 22 of file lib/network/quic/connection.c.

Referenced by quic_connection_datagram_payload().

QUIC_FLOW_COUNT

#define QUIC_FLOW_COUNT   3

Definition at line 20 of file lib/network/quic/connection.c.

Referenced by quic_connection_destroy(), quic_connection_expiry(), quic_connection_finish_stream(), quic_connection_received_fin(), and quic_connection_submit().

QUIC_HTTP3_PEER_UNI_STREAMS

#define QUIC_HTTP3_PEER_UNI_STREAMS   6U

Definition at line 23 of file lib/network/quic/connection.c.

QUIC_IDLE_TIMEOUT_NS

#define QUIC_IDLE_TIMEOUT_NS   (30ULL * 1000000000ULL)

Definition at line 19 of file lib/network/quic/connection.c.

QUIC_INITIAL_CONNECTION_WINDOW

#define QUIC_INITIAL_CONNECTION_WINDOW   (16U * 1024U * 1024U)

Definition at line 18 of file lib/network/quic/connection.c.

QUIC_INITIAL_STREAM_WINDOW

#define QUIC_INITIAL_STREAM_WINDOW   (5U * 1024U * 1024U)

Definition at line 17 of file lib/network/quic/connection.c.

Typedef Documentation

datagram_send_t

typedef struct datagram_send datagram_send_t

send_chunk_t

typedef struct send_chunk send_chunk_t

Function Documentation

quic_connection_accept_ready()

bool quic_connection_accept_ready

(

const quic_connection_t *

connection

)

Shared listeners wait for TLS ALPN and, for h3, an accepted CONNECT.

Definition at line 1484 of file lib/network/quic/connection.c.

                                                                       {
  return connection && connection->tls_ready && !connection->failed &&
         (!connection->webtransport || !connection->tls->webtransport ||
          quic_connection_webtransport_ready(connection));
}

References quic_connection::failed, quic_connection_webtransport_ready(), quic_connection::tls, quic_connection::tls_ready, quic_connection::webtransport, and quic_tls_t::webtransport.

Referenced by quic_accept().

quic_connection_allow_media()

asciichat_error_t quic_connection_allow_media

(

quic_connection_t *

connection

)

Permit outbound media after the authenticated readiness exchange. The owner must separately coordinate later application control barriers.

Definition at line 974 of file lib/network/quic/connection.c.

                                                                             {
  if (!connection || !connection->conn || connection->failed || !connection->tls_ready || !connection->security ||
      !connection->peer_security_ready)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC and authenticated ACIP encryption are not ready for media");
  connection->media_allowed = true;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_INVALID_STATE, quic_connection::failed, quic_connection::media_allowed, quic_connection::peer_security_ready, quic_connection::security, SET_ERRNO, and quic_connection::tls_ready.

Referenced by quic_transport_allow_media().

quic_connection_clear_receiver()

asciichat_error_t quic_connection_clear_receiver	(	quic_connection_t *	connection,
		void *	context )

Detach the current receiver on the connection lane before freeing its context.

Definition at line 947 of file lib/network/quic/connection.c.

                                                                                               {
  if (!connection || !connection->emit || connection->emit_context != context)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC receive callback context");
  connection->emit = NULL;
  connection->emit_context = NULL;
  connection->security_notify = NULL;
  connection->security_notify_context = NULL;
  connection->keyframe_notify = NULL;
  connection->keyframe_notify_context = NULL;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::emit, quic_connection::emit_context, ERROR_INVALID_PARAM, quic_connection::keyframe_notify, quic_connection::keyframe_notify_context, quic_connection::security_notify, quic_connection::security_notify_context, and SET_ERRNO.

quic_connection_client_create()

asciichat_error_t quic_connection_client_create	(	quic_tls_t *	tls,
		const char *	server_name,
		const ngtcp2_path *	path,
		uint64_t	now_ns,
		quic_connection_t **	out )

Definition at line 808 of file lib/network/quic/connection.c.

                                                                                          {
  return quic_connection_create(tls, server_name, path, NULL, NULL, now_ns, out);
}

References out.

Referenced by quic_udp_connect().

quic_connection_datagram_payload()

size_t quic_connection_datagram_payload

(

const quic_connection_t *

connection

)

Definition at line 1011 of file lib/network/quic/connection.c.

                                                                             {
  if (!connection || !connection->conn || connection->failed || !connection->tls_ready ||
      !connection->datagrams_enabled)
    return 0;
  const ngtcp2_transport_params *remote = ngtcp2_conn_get_remote_transport_params2(connection->conn);
  if (!remote || remote->max_datagram_frame_size <= QUIC_DATAGRAM_HEADER_SIZE + 9)
    return 0;
  size_t path = ngtcp2_conn_get_path_max_tx_udp_payload_size2(connection->conn);
  if (path <= QUIC_DATAGRAM_OVERHEAD + QUIC_DATAGRAM_HEADER_SIZE)
    return 0;
  size_t frame = path - QUIC_DATAGRAM_OVERHEAD;
  if (frame > QUIC_DATAGRAM_FRAME_LIMIT)
    frame = QUIC_DATAGRAM_FRAME_LIMIT;
  if (frame > remote->max_datagram_frame_size - 9)
    frame = (size_t)(remote->max_datagram_frame_size - 9);
  if (connection->webtransport) {
    int64_t session_id = -1;
    uint8_t prefix[8];
    if (!connection->http3 || !http_server_http3_accepted(connection->http3, &session_id))
      return 0;
    size_t size = write_quic_varint(prefix, (uint64_t)session_id / 4);
    if (frame <= size)
      return 0;
    frame -= size;
  }
  return frame > QUIC_DATAGRAM_HEADER_SIZE ? frame - QUIC_DATAGRAM_HEADER_SIZE : 0;
}

References quic_connection::conn, quic_connection::datagrams_enabled, quic_connection::failed, quic_connection::http3, http_server_http3_accepted(), QUIC_DATAGRAM_FRAME_LIMIT, QUIC_DATAGRAM_HEADER_SIZE, QUIC_DATAGRAM_OVERHEAD, session_id, quic_connection::tls_ready, and quic_connection::webtransport.

Referenced by quic_connection_submit_datagram(), and quic_connection_validate_datagram().

quic_connection_destroy()

void quic_connection_destroy

(

quic_connection_t **

connection

)

Definition at line 1512 of file lib/network/quic/connection.c.

                                                             {
  if (!connection || !*connection)
    return;
  ngtcp2_conn_del((*connection)->conn);
  (*connection)->conn = NULL;
  http_server_http3_destroy(&(*connection)->http3);
  buffer_release((*connection)->early_security_packet);
  quic_datagram_reset(&(*connection)->datagram_reader);
  for (size_t i = 0; i < QUIC_FLOW_COUNT; ++i) {
    while ((*connection)->datagram_head[i])
      pop_datagram(*connection, (acip_traffic_class_t)i);
    send_chunk_t *chunk = (*connection)->sends[i].head;
    while (chunk) {
      send_chunk_t *next = chunk->next;
      free_chunk(*connection, chunk);
      chunk = next;
    }
    quic_stream_reset(&(*connection)->receives[i].reader);
  }
  quic_tls_session_destroy(&(*connection)->ssl);
  ngtcp2_crypto_ossl_ctx_del((*connection)->crypto);
  (*connection)->security = NULL;
  SAFE_FREE(*connection);
}

References buffer_release, http_server_http3_destroy(), send_chunk::next, quic_datagram_reset(), QUIC_FLOW_COUNT, quic_stream_reset(), quic_tls_session_destroy(), and SAFE_FREE.

Referenced by quic_udp_remove().

quic_connection_enable_security()

asciichat_error_t quic_connection_enable_security	(	quic_connection_t *	connection,
		crypto_context_t *	crypto )

Enable authenticated ACIP framing after the local ACIP handshake. This queues a readiness marker and handles the peer's marker and acknowledgement. The crypto context is borrowed until connection destruction. The endpoint must serialize every operation on it, including rekeying, with this engine.

Definition at line 982 of file lib/network/quic/connection.c.

                                                                                                           {
  if (!connection || !connection->conn || connection->failed || !connection->tls_ready || !connection->emit)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC is not ready for the ACIP security transition");
  crypto->server_role = connection->tls->server;
  crypto->server_role_known = true;
  crypto_session_t *session = NULL;
  asciichat_error_t result = crypto_session_lock(crypto, &session);
  if (result == ASCIICHAT_OK) {
    crypto_session_unlock(session);
    connection->security = crypto;
  }
  if (result != ASCIICHAT_OK)
    return result;
  result = queue_security_barrier(connection, quic_ready_payload, sizeof(quic_ready_payload));
  if (result == ASCIICHAT_OK && connection->early_security_packet)
    result = open_security_packet(connection, ACIP_TRAFFIC_CONTROL, connection->early_security_packet,
                                  connection->early_security_length);
  buffer_release(connection->early_security_packet);
  connection->early_security_packet = NULL;
  connection->early_security_length = 0;
  if (result != ASCIICHAT_OK)
    connection->failed = true;
  return result;
}

References ACIP_TRAFFIC_CONTROL, ASCIICHAT_OK, buffer_release, quic_connection::conn, crypto_session_lock(), crypto_session_unlock(), quic_connection::early_security_length, quic_connection::early_security_packet, quic_connection::emit, ERROR_INVALID_STATE, quic_connection::failed, quic_connection::security, quic_tls_t::server, crypto_context_t::server_role, crypto_context_t::server_role_known, SET_ERRNO, quic_connection::tls, and quic_connection::tls_ready.

Referenced by quic_transport_begin_security().

quic_connection_expiry()

uint64_t quic_connection_expiry

(

const quic_connection_t *

connection

)

Definition at line 1453 of file lib/network/quic/connection.c.

                                                                     {
  if (!connection || !connection->conn || connection->failed)
    return UINT64_MAX;
  uint64_t expiry = ngtcp2_conn_get_expiry(connection->conn);
  for (size_t i = 0; i < QUIC_FLOW_COUNT; ++i)
    for (const datagram_send_t *item = connection->datagram_head[i]; item; item = item->next)
      if (item->deadline_ns && item->deadline_ns < expiry)
        expiry = item->deadline_ns;
  for (size_t i = 0; i < QUIC_DATAGRAM_SLOTS; ++i) {
    const quic_datagram_slot_t *slot = &connection->datagram_reader.slots[i];
    if (slot->data && slot->started_ns <= UINT64_MAX - QUIC_DATAGRAM_EXPIRY_NS &&
        slot->started_ns + QUIC_DATAGRAM_EXPIRY_NS < expiry)
      expiry = slot->started_ns + QUIC_DATAGRAM_EXPIRY_NS;
  }
  return expiry;
}

References quic_connection::conn, quic_datagram_slot_t::data, quic_connection::datagram_head, quic_connection::datagram_reader, datagram_send::deadline_ns, quic_connection::failed, datagram_send::next, QUIC_DATAGRAM_EXPIRY_NS, QUIC_DATAGRAM_SLOTS, QUIC_FLOW_COUNT, quic_datagram_reader_t::slots, and quic_datagram_slot_t::started_ns.

Referenced by quic_udp_pump(), and quic_udp_wait_parameters().

quic_connection_finish_stream()

asciichat_error_t quic_connection_finish_stream	(	quic_connection_t *	connection,
		acip_traffic_class_t	traffic_class )

Definition at line 1233 of file lib/network/quic/connection.c.

                                                                                                                   {
  if (!connection || !connection->conn || connection->failed || (unsigned)traffic_class >= QUIC_FLOW_COUNT)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC traffic stream");
  send_stream_t *stream = &connection->sends[traffic_class];
  if (!stream->initialized || stream->fin_requested)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC traffic stream is not open or is already closing");
  stream->fin_requested = true;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, quic_connection::failed, send_stream_t::fin_requested, send_stream_t::initialized, QUIC_FLOW_COUNT, quic_connection::sends, and SET_ERRNO.

quic_connection_handle_expiry()

asciichat_error_t quic_connection_handle_expiry	(	quic_connection_t *	connection,
		uint64_t	now_ns )

Definition at line 1470 of file lib/network/quic/connection.c.

                                                                                                {
  if (!connection || !connection->conn || connection->failed)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC timeout state");
  asciichat_error_t result = update_time(connection, now_ns);
  if (result != ASCIICHAT_OK)
    return result;
  int rc = ngtcp2_conn_get_expiry(connection->conn) <= now_ns ? ngtcp2_conn_handle_expiry(connection->conn, now_ns) : 0;
  if (rc != 0) {
    connection->failed = true;
    return SET_ERRNO(ERROR_NETWORK_TIMEOUT, "QUIC timer failed: %s", ngtcp2_strerror(rc));
  }
  return update_readiness(connection);
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_INVALID_PARAM, ERROR_NETWORK_TIMEOUT, quic_connection::failed, and SET_ERRNO.

Referenced by quic_udp_pump().

quic_connection_matches_cid()

asciichat_error_t quic_connection_matches_cid	(	const quic_connection_t *	connection,
		const uint8_t *	cid,
		size_t	length,
		bool *	matches )

Definition at line 908 of file lib/network/quic/connection.c.

                                                             {
  if (!connection || !connection->conn || !cid || !matches)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC connection ID lookup");
  *matches = false;
  if (!length || length > NGTCP2_MAX_CIDLEN)
    return ASCIICHAT_OK;
  if (connection->has_initial_dcid && length == connection->initial_dcid.datalen &&
      memcmp(cid, connection->initial_dcid.data, length) == 0) {
    *matches = true;
    return ASCIICHAT_OK;
  }
  size_t count = ngtcp2_conn_get_scid2(connection->conn, NULL);
  if (!count)
    return ASCIICHAT_OK;
  if (count > SIZE_MAX / sizeof(ngtcp2_cid))
    return SET_ERRNO(ERROR_MEMORY, "QUIC connection ID count overflow");
  ngtcp2_cid *ids = SAFE_CALLOC(count, sizeof(*ids), ngtcp2_cid *);
  if (!ids)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate QUIC connection ID list");
  size_t actual = ngtcp2_conn_get_scid2(connection->conn, ids);
  for (size_t i = 0; i < actual; ++i) {
    if (ids[i].datalen == length && memcmp(ids[i].data, cid, length) == 0) {
      *matches = true;
      break;
    }
  }
  SAFE_FREE(ids);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_INVALID_PARAM, ERROR_MEMORY, quic_connection::has_initial_dcid, quic_connection::initial_dcid, SAFE_CALLOC, SAFE_FREE, and SET_ERRNO.

quic_connection_migrate()

asciichat_error_t quic_connection_migrate	(	quic_connection_t *	connection,
		const struct sockaddr *	local,
		socklen_t	length,
		uint64_t	now_ns )

Definition at line 1537 of file lib/network/quic/connection.c.

                                                           {
  if (!connection || !connection->conn || connection->failed || connection->tls->server || !local ||
      (size_t)length > sizeof(ngtcp2_sockaddr_union))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC client migration");
  const ngtcp2_path *current = ngtcp2_conn_get_path2(connection->conn);
  ngtcp2_path path = *current;
  path.local.addr = (struct sockaddr *)local;
  path.local.addrlen = length;
  if (!valid_address(&path.local) || local->sa_family != current->remote.addr->sa_family)
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC migration requires a concrete address in the peer address family");
  asciichat_error_t result = update_time(connection, now_ns);
  if (result != ASCIICHAT_OK)
    return result;
  int rc = ngtcp2_conn_initiate_immediate_migration(connection->conn, &path, now_ns);
  if (rc == NGTCP2_ERR_INVALID_STATE)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC handshake is unconfirmed or peer disabled active migration");
  if (rc == NGTCP2_ERR_CONN_ID_BLOCKED)
    return SET_ERRNO(ERROR_BUFFER_FULL, "QUIC migration requires an unused peer connection ID");
  if (rc != 0)
    return SET_ERRNO(ERROR_NETWORK, "Cannot initiate QUIC migration: %s", ngtcp2_strerror(rc));
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_BUFFER_FULL, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK, quic_connection::failed, quic_tls_t::server, SET_ERRNO, and quic_connection::tls.

Referenced by quic_udp_migrate().

quic_connection_packet_sent()

asciichat_error_t quic_connection_packet_sent	(	quic_connection_t *	connection,
		uint64_t	now_ns )

Definition at line 1442 of file lib/network/quic/connection.c.

                                                                                              {
  if (!connection || !connection->conn || connection->failed || !connection->packet_pending)
    return SET_ERRNO(ERROR_INVALID_STATE, "No QUIC packet awaiting transmission");
  asciichat_error_t result = update_time(connection, now_ns);
  if (result != ASCIICHAT_OK)
    return result;
  ngtcp2_conn_update_pkt_tx_time(connection->conn, now_ns);
  connection->packet_pending = false;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_INVALID_STATE, quic_connection::failed, quic_connection::packet_pending, and SET_ERRNO.

Referenced by quic_udp_pump().

quic_connection_peer_address()

asciichat_error_t quic_connection_peer_address	(	const quic_connection_t *	connection,
		struct sockaddr_storage *	address,
		socklen_t *	length )

Definition at line 1499 of file lib/network/quic/connection.c.

                                                                  {
  if (!connection || !connection->conn || connection->failed || !address || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC peer address query");
  const ngtcp2_path *path = ngtcp2_conn_get_path2(connection->conn);
  if (!path || !valid_address(&path->remote))
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC peer address is unavailable");
  memset(address, 0, sizeof(*address));
  memcpy(address, path->remote.addr, (size_t)path->remote.addrlen);
  *length = path->remote.addrlen;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, quic_connection::failed, and SET_ERRNO.

Referenced by quic_transport_peer_address().

quic_connection_pending_bytes()

size_t quic_connection_pending_bytes

(

const quic_connection_t *

connection

)

Definition at line 1229 of file lib/network/quic/connection.c.

                                                                          {
  return connection ? connection->pending_bytes : 0;
}

References quic_connection::pending_bytes.

quic_connection_pending_packet_class()

bool quic_connection_pending_packet_class	(	const quic_connection_t *	connection,
		acip_traffic_class_t *	traffic_class )

Reports the class of newly submitted stream or datagram data in the pending packet. Retransmissions from other streams may also be present in that packet.

Definition at line 1387 of file lib/network/quic/connection.c.

                                                                                                                    {
  if (!connection || !connection->packet_pending || !connection->packet_has_stream_data || !traffic_class)
    return false;
  *traffic_class = connection->packet_traffic_class;
  return true;
}

References quic_connection::packet_has_stream_data, quic_connection::packet_pending, and quic_connection::packet_traffic_class.

quic_connection_receive()

asciichat_error_t quic_connection_receive	(	quic_connection_t *	connection,
		const ngtcp2_path *	path,
		const void *	packet,
		size_t	length,
		uint64_t	now_ns )

Definition at line 1252 of file lib/network/quic/connection.c.

                                                                          {
  if (!connection || !connection->conn || connection->failed || !valid_path(path) || !packet || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC packet input");
  asciichat_error_t result = update_time(connection, now_ns);
  if (result != ASCIICHAT_OK)
    return result;
  ngtcp2_pkt_info info = {0};
  connection->callback_error = ASCIICHAT_OK;
  int rc = ngtcp2_conn_read_pkt(connection->conn, path, &info, packet, length, now_ns);
  if (rc != 0) {
    connection->failed = true;
    asciichat_error_t code = connection->callback_error != ASCIICHAT_OK ? connection->callback_error
                             : rc == NGTCP2_ERR_CRYPTO                  ? ERROR_CRYPTO
                             : rc == NGTCP2_ERR_DRAINING                ? ERROR_NETWORK
                                                                        : ERROR_NETWORK_PROTOCOL;
    return SET_ERRNO(code, "QUIC receive failed: %s", ngtcp2_strerror(rc));
  }
  return update_readiness(connection);
}

References ASCIICHAT_OK, quic_connection::callback_error, quic_connection::conn, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_NETWORK, ERROR_NETWORK_PROTOCOL, quic_connection::failed, and SET_ERRNO.

quic_connection_received_fin()

bool quic_connection_received_fin	(	const quic_connection_t *	connection,
		acip_traffic_class_t	traffic_class )

Definition at line 1243 of file lib/network/quic/connection.c.

                                                                                                           {
  if (!connection || (unsigned)traffic_class >= QUIC_FLOW_COUNT)
    return false;
  for (size_t i = 0; i < QUIC_FLOW_COUNT; ++i)
    if (connection->receives[i].registered && connection->receives[i].reader.traffic_class == traffic_class)
      return connection->receives[i].reader.finished;
  return false;
}

References quic_stream_reader_t::finished, QUIC_FLOW_COUNT, receive_stream_t::reader, quic_connection::receives, receive_stream_t::registered, and quic_stream_reader_t::traffic_class.

quic_connection_security_ready()

bool quic_connection_security_ready

(

const quic_connection_t *

connection

)

True after the peer's authenticated READY and acknowledgement are received.

Definition at line 1007 of file lib/network/quic/connection.c.

                                                                         {
  return connection && connection->security && connection->peer_security_ready && !connection->failed;
}

References quic_connection::failed, quic_connection::peer_security_ready, and quic_connection::security.

Referenced by quic_transport_security_ready(), and quic_transport_wait_security().

quic_connection_server_create()

asciichat_error_t quic_connection_server_create	(	quic_tls_t *	tls,
		const ngtcp2_path *	path,
		const void *	initial,
		size_t	initial_length,
		uint64_t	now_ns,
		quic_connection_t **	out )

Creates a server connection for an acceptable QUIC v1 Initial packet. The caller must subsequently pass that same packet to receive().

Definition at line 813 of file lib/network/quic/connection.c.

                                                                                                                 {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC connection output");
  *out = NULL;
  if (!initial || !initial_length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC Initial packet");
  ngtcp2_pkt_hd header;
  int rc = ngtcp2_accept(&header, initial, initial_length);
  if (rc != 0 || header.version != NGTCP2_PROTO_VER_V1)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid or unsupported QUIC Initial packet");
  return quic_connection_create(tls, NULL, path, &header, NULL, now_ns, out);
}

References ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, out, and SET_ERRNO.

quic_connection_server_create_validated()

asciichat_error_t quic_connection_server_create_validated	(	quic_tls_t *	tls,
		const ngtcp2_path *	path,
		const void *	initial,
		size_t	initial_length,
		const ngtcp2_cid *	original_dcid,
		uint64_t	now_ns,
		quic_connection_t **	out )

Definition at line 827 of file lib/network/quic/connection.c.

                                                                                                    {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC connection output");
  *out = NULL;
  if (!initial || !initial_length || !original_dcid || !original_dcid->datalen ||
      original_dcid->datalen > NGTCP2_MAX_CIDLEN)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing validated QUIC Initial parameters");
  ngtcp2_pkt_hd header;
  int rc = ngtcp2_accept(&header, initial, initial_length);
  if (rc != 0 || header.version != NGTCP2_PROTO_VER_V1 || !header.tokenlen)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid validated QUIC Initial packet");
  return quic_connection_create(tls, NULL, path, &header, original_dcid, now_ns, out);
}

References ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, out, and SET_ERRNO.

quic_connection_set_keyframe_notifier()

void quic_connection_set_keyframe_notifier	(	quic_connection_t *	connection,
		void(*	notify )(uint16_t, uint32_t, void *),
		void *	context )

Definition at line 959 of file lib/network/quic/connection.c.

                                                          {
  if (connection) {
    connection->keyframe_notify = notify;
    connection->keyframe_notify_context = notify ? context : NULL;
  }
}

References quic_connection::keyframe_notify, and quic_connection::keyframe_notify_context.

quic_connection_set_receiver()

asciichat_error_t quic_connection_set_receiver	(	quic_connection_t *	connection,
		quic_stream_emit_fn	emit,
		void *	context )

Install a serialized receive callback. It borrows complete wire packets; the callback must copy what it retains and must not reenter the connection.

Definition at line 939 of file lib/network/quic/connection.c.

                                                                                                                       {
  if (!connection || !connection->conn || connection->failed || !emit || connection->emit)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC receive callback");
  connection->emit = emit;
  connection->emit_context = context;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, quic_connection::emit, quic_connection::emit_context, ERROR_INVALID_PARAM, quic_connection::failed, and SET_ERRNO.

quic_connection_set_security_notifier()

void quic_connection_set_security_notifier	(	quic_connection_t *	connection,
		void(*	notify )(void *),
		void *	context )

The notifier runs on the serialized lane when the readiness exchange completes.

Definition at line 967 of file lib/network/quic/connection.c.

                                                                                                                 {
  if (connection) {
    connection->security_notify = notify;
    connection->security_notify_context = notify ? context : NULL;
  }
}

References quic_connection::security_notify, and quic_connection::security_notify_context.

quic_connection_submit()

asciichat_error_t quic_connection_submit	(	quic_connection_t *	connection,
		acip_traffic_class_t	traffic_class,
		const void *	packet,
		size_t	length )

Copy one complete ACIP wire packet to its reliable stream. Admission is bounded; ERROR_BUFFER_FULL leaves the queue unchanged. The connection owns submitted bytes until ngtcp2 acknowledges them or the connection is freed.

Definition at line 1187 of file lib/network/quic/connection.c.

                                                                            {
  if (connection && !connection->security && packet && length >= sizeof(packet_header_t)) {
    packet_header_t header;
    memcpy(&header, packet, sizeof(header));
    packet_type_t type = NET_TO_HOST_U16(header.type);
    if (traffic_class == ACIP_TRAFFIC_CONTROL && !initial_handshake_packet(type))
      return SET_ERRNO(ERROR_CRYPTO, "Non-handshake ACIP packet sent before authentication");
  }
  if (!connection || !connection->security)
    return queue_wire_packet(connection, traffic_class, packet, length);
  if (packet && length >= sizeof(packet_header_t)) {
    packet_header_t header;
    memcpy(&header, packet, sizeof(header));
    if (NET_TO_HOST_U16(header.type) == PACKET_TYPE_ENCRYPTED)
      return queue_wire_packet_internal(connection, traffic_class, packet, length, true);
  }
  if (!connection->peer_security_ready)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC peer has not acknowledged ACIP security readiness");
  if (packet && length >= sizeof(packet_header_t)) {
    packet_header_t header;
    memcpy(&header, packet, sizeof(header));
    if (NET_TO_HOST_U16(header.type) == PACKET_TYPE_QUIC_READY ||
        NET_TO_HOST_U16(header.type) == PACKET_TYPE_QUIC_KEYFRAME_REQUEST ||
        acip_security_rekey_packet(NET_TO_HOST_U16(header.type)))
      return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC readiness marker is reserved");
  }
  if (!connection->conn || connection->failed || !connection->tls_ready || (unsigned)traffic_class >= QUIC_FLOW_COUNT ||
      (traffic_class != ACIP_TRAFFIC_CONTROL && !connection->media_allowed))
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC connection is not ready for this traffic");
  if (connection->sends[traffic_class].fin_requested)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC traffic stream is closing");
  uint8_t *wire = NULL;
  size_t wire_length = 0;
  asciichat_error_t result = acip_security_seal(connection->security, traffic_class, ACIP_DELIVERY_RELIABLE, packet,
                                                length, &wire, &wire_length);
  if (result == ASCIICHAT_OK)
    result = queue_wire_packet(connection, traffic_class, wire, wire_length);
  buffer_release(wire);
  return result;
}

References ACIP_DELIVERY_RELIABLE, acip_security_rekey_packet(), acip_security_seal(), ACIP_TRAFFIC_CONTROL, ASCIICHAT_OK, buffer_release, quic_connection::conn, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, quic_connection::failed, send_stream_t::fin_requested, quic_connection::media_allowed, NET_TO_HOST_U16, PACKET_TYPE_ENCRYPTED, PACKET_TYPE_QUIC_KEYFRAME_REQUEST, PACKET_TYPE_QUIC_READY, quic_connection::peer_security_ready, QUIC_FLOW_COUNT, quic_connection::security, quic_connection::sends, SET_ERRNO, and quic_connection::tls_ready.

quic_connection_submit_datagram()

asciichat_error_t quic_connection_submit_datagram	(	quic_connection_t *	connection,
		acip_traffic_class_t	flow,
		const void *	packet,
		size_t	length,
		uint64_t	deadline_ns )

Definition at line 1052 of file lib/network/quic/connection.c.

                                                                                                           {
  asciichat_error_t validation = quic_connection_validate_datagram(connection, flow, deadline_ns);
  if (validation != ASCIICHAT_OK)
    return validation;
  if (flow == ACIP_TRAFFIC_VISUAL && packet && length >= sizeof(packet_header_t)) {
    packet_header_t header;
    memcpy(&header, packet, sizeof(header));
    uint16_t type = NET_TO_HOST_U16(header.type);
    if ((type == PACKET_TYPE_IMAGE_FRAME_H264 || type == PACKET_TYPE_IMAGE_FRAME_H265) && header.client_id != 0)
      return SET_ERRNO(ERROR_NOT_SUPPORTED, "QUIC encoded datagrams require stream ID zero");
  }
  size_t unit = quic_connection_datagram_payload(connection);
  if (connection->datagram_id[flow] == UINT64_MAX)
    return SET_ERRNO(ERROR_NETWORK_SIZE, "QUIC datagram ID exhausted");
  size_t reserve = flow == ACIP_TRAFFIC_VISUAL ? ACIP_OUTBOUND_CONTROL_RESERVE + ACIP_OUTBOUND_AUDIO_RESERVE
                                               : ACIP_OUTBOUND_CONTROL_RESERVE;
  size_t limit = ACIP_OUTBOUND_BUDGET - reserve;
  if (connection->pending_bytes > limit || length > limit - connection->pending_bytes)
    return SET_ERRNO(ERROR_BUFFER_FULL, "QUIC datagram queue is full");
  uint8_t *wire = NULL;
  size_t wire_length = 0;
  asciichat_error_t result =
      acip_security_seal(connection->security, flow, ACIP_DELIVERY_DATAGRAM, packet, length, &wire, &wire_length);
  if (result != ASCIICHAT_OK)
    return result;
  size_t count = (wire_length + unit - 1) / unit;
  size_t cost = buffer_capacity(wire) + sizeof(datagram_send_t);
  if (count > QUIC_DATAGRAM_MAX_FRAGMENTS || cost > limit - connection->pending_bytes) {
    buffer_release(wire);
    return SET_ERRNO(count > QUIC_DATAGRAM_MAX_FRAGMENTS ? ERROR_NETWORK_SIZE : ERROR_BUFFER_FULL,
                     "QUIC datagram exceeds fragmentation or queue limit");
  }
  datagram_send_t *item = SAFE_CALLOC(1, sizeof(*item), datagram_send_t *);
  if (!item) {
    buffer_release(wire);
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate QUIC datagram queue entry");
  }
  item->data = wire;
  item->length = wire_length;
  item->cost = cost;
  item->id = ++connection->datagram_id[flow];
  item->deadline_ns = deadline_ns;
  item->unit = (uint16_t)unit;
  item->count = (uint16_t)count;
  if (connection->datagram_tail[flow])
    connection->datagram_tail[flow]->next = item;
  else
    connection->datagram_head[flow] = item;
  connection->datagram_tail[flow] = item;
  connection->pending_bytes += cost;
  return ASCIICHAT_OK;
}

References ACIP_DELIVERY_DATAGRAM, ACIP_OUTBOUND_AUDIO_RESERVE, ACIP_OUTBOUND_BUDGET, ACIP_OUTBOUND_CONTROL_RESERVE, acip_security_seal(), ACIP_TRAFFIC_VISUAL, ASCIICHAT_OK, buffer_capacity(), buffer_release, datagram_send::cost, datagram_send::count, datagram_send::data, quic_connection::datagram_head, quic_connection::datagram_id, quic_connection::datagram_tail, datagram_send::deadline_ns, ERROR_BUFFER_FULL, ERROR_MEMORY, ERROR_NETWORK_SIZE, ERROR_NOT_SUPPORTED, datagram_send::id, datagram_send::length, NET_TO_HOST_U16, datagram_send::next, PACKET_TYPE_IMAGE_FRAME_H264, PACKET_TYPE_IMAGE_FRAME_H265, quic_connection::pending_bytes, quic_connection_datagram_payload(), quic_connection_validate_datagram(), QUIC_DATAGRAM_MAX_FRAGMENTS, SAFE_CALLOC, quic_connection::security, SET_ERRNO, and datagram_send::unit.

quic_connection_tls_ready()

bool quic_connection_tls_ready

(

const quic_connection_t *

connection

)

Definition at line 1495 of file lib/network/quic/connection.c.

                                                                    {
  return connection && !connection->failed && connection->tls_ready;
}

References quic_connection::failed, and quic_connection::tls_ready.

quic_connection_validate_datagram()

asciichat_error_t quic_connection_validate_datagram	(	const quic_connection_t *	connection,
		acip_traffic_class_t	flow,
		uint64_t	deadline_ns )

Definition at line 1039 of file lib/network/quic/connection.c.

                                                                          {
  if (!connection || (flow != ACIP_TRAFFIC_AUDIO && flow != ACIP_TRAFFIC_VISUAL))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC datagram flow");
  if (!quic_connection_datagram_payload(connection))
    return SET_ERRNO(ERROR_NOT_SUPPORTED, "QUIC datagrams were not negotiated");
  if (!connection->security || !connection->peer_security_ready || !connection->media_allowed)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC media security is not ready");
  if (deadline_ns && deadline_ns <= connection->last_time_ns)
    return SET_ERRNO(ERROR_NETWORK_TIMEOUT, "QUIC datagram deadline expired");
  return ASCIICHAT_OK;
}

References ACIP_TRAFFIC_AUDIO, ACIP_TRAFFIC_VISUAL, ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK_TIMEOUT, ERROR_NOT_SUPPORTED, quic_connection::media_allowed, quic_connection::peer_security_ready, quic_connection_datagram_payload(), quic_connection::security, and SET_ERRNO.

Referenced by quic_connection_submit_datagram().

quic_connection_webtransport_ready()

bool quic_connection_webtransport_ready

(

const quic_connection_t *

connection

)

Definition at line 1490 of file lib/network/quic/connection.c.

                                                                             {
  return connection && connection->webtransport && connection->http3 &&
         http_server_http3_accepted(connection->http3, NULL) && !connection->failed;
}

References quic_connection::failed, quic_connection::http3, http_server_http3_accepted(), and quic_connection::webtransport.

Referenced by quic_connection_accept_ready().

quic_connection_write()

asciichat_error_t quic_connection_write	(	quic_connection_t *	connection,
		ngtcp2_path_storage *	path,
		void *	packet,
		size_t	capacity,
		size_t *	length,
		uint64_t	now_ns )

Writes a single UDP payload, or sets length to zero if no packet is ready. The returned path identifies the local and remote addresses for that packet. The endpoint must retain an unsent payload across socket backpressure and call packet_sent after successful transmission, before writing another.

Definition at line 1417 of file lib/network/quic/connection.c.

                                                                                          {
  if (!length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC packet length output");
  *length = 0;
  if (!connection || !connection->conn || connection->failed || !path || !packet || capacity < 1200)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC packet output");
  if (connection->packet_pending)
    return SET_ERRNO(ERROR_INVALID_STATE, "Previous QUIC packet has not been transmitted");
  asciichat_error_t result = update_time(connection, now_ns);
  if (result != ASCIICHAT_OK)
    return result;
  ngtcp2_path_storage_zero(path);
  ngtcp2_pkt_info info = {0};
  ngtcp2_ssize written = write_pending(connection, &path->path, &info, packet, capacity, now_ns);
  if (written < 0) {
    connection->failed = true;
    return SET_ERRNO(written == NGTCP2_ERR_CRYPTO ? ERROR_CRYPTO : ERROR_NETWORK, "QUIC write failed: %s",
                     ngtcp2_strerror((int)written));
  }
  *length = (size_t)written;
  connection->packet_pending = written > 0;
  return update_readiness(connection);
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK, quic_connection::failed, quic_connection::packet_pending, and SET_ERRNO.

Referenced by quic_udp_pump().

quic_connection_write_close()

asciichat_error_t quic_connection_write_close	(	quic_connection_t *	connection,
		ngtcp2_path_storage *	path,
		void *	packet,
		size_t	capacity,
		size_t *	length,
		uint64_t	now_ns )

Definition at line 1394 of file lib/network/quic/connection.c.

                                                                                                {
  if (!connection || !connection->conn || !path || !packet || capacity < 1200 || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC close packet output");
  *length = 0;
  if (connection->failed || ngtcp2_conn_in_closing_period2(connection->conn) ||
      ngtcp2_conn_in_draining_period2(connection->conn))
    return ASCIICHAT_OK;
  asciichat_error_t result = update_time(connection, now_ns);
  if (result != ASCIICHAT_OK)
    return result;
  ngtcp2_path_storage_zero(path);
  ngtcp2_pkt_info info = {0};
  ngtcp2_ccerr close_error;
  ngtcp2_ccerr_default(&close_error);
  ngtcp2_ssize written =
      ngtcp2_conn_write_connection_close(connection->conn, &path->path, &info, packet, capacity, &close_error, now_ns);
  if (written < 0)
    return SET_ERRNO(ERROR_NETWORK, "Cannot write QUIC close packet: %s", ngtcp2_strerror((int)written));
  *length = (size_t)written;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, quic_connection::conn, ERROR_INVALID_PARAM, ERROR_NETWORK, quic_connection::failed, and SET_ERRNO.

Referenced by quic_udp_close_peer().