quic.h File Reference

Go to the source code of this file.

Data Structures
struct	quic_config_t

Functions
asciichat_error_t	quic_endpoint_set_http_server (quic_endpoint_t *endpoint, http_server_t *server)
asciichat_error_t	quic_endpoint_open (const struct sockaddr *bind_address, socklen_t bind_length, bool listener, const quic_config_t *config, quic_endpoint_t **out)
asciichat_error_t	quic_endpoint_address (quic_endpoint_t *endpoint, struct sockaddr_storage *address, socklen_t *length)
asciichat_error_t	quic_connect (quic_endpoint_t *endpoint, const struct sockaddr *remote, socklen_t remote_length, const char *server_name, acip_transport_t **out)
asciichat_error_t	quic_accept (quic_endpoint_t *endpoint, acip_transport_t **out)
asciichat_error_t	quic_transport_peer_address (acip_transport_t *transport, struct sockaddr_storage *address, socklen_t *length)
asciichat_error_t	quic_transport_begin_security (acip_transport_t *transport, crypto_context_t *crypto)
bool	quic_transport_security_ready (acip_transport_t *transport)
asciichat_error_t	quic_transport_wait_security (acip_transport_t *transport, uint64_t timeout_ns)
asciichat_error_t	quic_transport_allow_media (acip_transport_t *transport)
asciichat_error_t	quic_release (quic_endpoint_t *endpoint, acip_transport_t **transport)
asciichat_error_t	quic_endpoint_stop (quic_endpoint_t *endpoint)
asciichat_error_t	quic_endpoint_destroy (quic_endpoint_t **endpoint)
asciichat_error_t	quic_endpoint_migrate (quic_endpoint_t *endpoint, const struct sockaddr *local_address, socklen_t length)

Function Documentation

quic_accept()

asciichat_error_t quic_accept	(	quic_endpoint_t *	endpoint,
		acip_transport_t **	out )

Nonblocking accept. Returns ERROR_NETWORK_TIMEOUT when none is available. A returned transport is owned and may still be negotiating TLS.

Definition at line 255 of file endpoint.c.

                                                                                 {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC accept output");
  *out = NULL;
  if (!endpoint || !endpoint->listener)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC listener");
  mutex_lock(&endpoint->lane);
  endpoint_transport_t *item = endpoint->transports;
  bool generic_http3 = endpoint->tls->http3 && !endpoint->tls->webtransport;
  while (item && (item->claimed || generic_http3 ||
                  (endpoint->tls->webtransport && !quic_connection_accept_ready(item->connection))))
    item = item->next;
  asciichat_error_t result = ASCIICHAT_OK;
  if (item) {
    item->claimed = true;
    *out = item->transport;
  } else {
    result = endpoint->terminal_error ? SET_ERRNO(endpoint->terminal_error, "QUIC endpoint failed")
             : endpoint->stopping     ? SET_ERRNO(ERROR_INVALID_STATE, "QUIC endpoint stopped")
                                      : SET_ERRNO(ERROR_NETWORK_TIMEOUT, "No QUIC connection is available");
  }
  mutex_unlock(&endpoint->lane);
  return result;
}

References ASCIICHAT_OK, endpoint_transport::claimed, endpoint_transport::connection, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_NETWORK_TIMEOUT, quic_tls_t::http3, quic_endpoint::lane, quic_endpoint::listener, endpoint_transport::next, out, quic_connection_accept_ready(), SET_ERRNO, quic_endpoint::stopping, quic_endpoint::terminal_error, quic_endpoint::tls, endpoint_transport::transport, quic_endpoint::transports, and quic_tls_t::webtransport.

quic_connect()

asciichat_error_t quic_connect	(	quic_endpoint_t *	endpoint,
		const struct sockaddr *	remote,
		socklen_t	remote_length,
		const char *	server_name,
		acip_transport_t **	out )

Start a client connection to a resolved address. server_name is used for certificate identity verification and is required even for an IP address. The returned transport is owned by the caller and is initially negotiating TLS. Check capabilities for TLS readiness before ACIP handshake. No application media is enabled until ACIP authentication and readiness.

Definition at line 229 of file endpoint.c.

                                                                                {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC transport output");
  *out = NULL;
  if (!endpoint || endpoint->listener || !remote || !server_name || !*server_name)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC connect configuration");
  mutex_lock(&endpoint->lane);
  quic_connection_t *connection = NULL;
  asciichat_error_t result = endpoint->stopping         ? SET_ERRNO(ERROR_INVALID_STATE, "QUIC endpoint stopped")
                             : endpoint->terminal_error ? SET_ERRNO(endpoint->terminal_error, "QUIC endpoint failed")
                             : endpoint->count >= QUIC_ENDPOINT_MAX_TRANSPORTS
                                 ? SET_ERRNO(ERROR_BUFFER_FULL, "QUIC endpoint transport limit reached")
                                 : quic_udp_connect(endpoint->udp, endpoint->tls, server_name, remote, remote_length,
                                                    time_get_ns(), &connection);
  if (result == ASCIICHAT_OK) {
    result = attach(endpoint, connection, true, out);
    if (result != ASCIICHAT_OK)
      (void)quic_udp_remove(endpoint->udp, connection);
  }
  mutex_unlock(&endpoint->lane);
  if (result == ASCIICHAT_OK)
    wake_endpoint(endpoint);
  return result;
}

References ASCIICHAT_OK, quic_endpoint::count, ERROR_BUFFER_FULL, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, quic_endpoint::lane, quic_endpoint::listener, out, QUIC_ENDPOINT_MAX_TRANSPORTS, quic_udp_connect(), quic_udp_remove(), SET_ERRNO, quic_endpoint::stopping, quic_endpoint::terminal_error, quic_endpoint::tls, and quic_endpoint::udp.

quic_endpoint_address()

asciichat_error_t quic_endpoint_address	(	quic_endpoint_t *	endpoint,
		struct sockaddr_storage *	address,
		socklen_t *	length )

Definition at line 219 of file endpoint.c.

                                                           {
  if (!endpoint)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC endpoint");
  mutex_lock(&endpoint->lane);
  asciichat_error_t result = quic_udp_endpoint_address(endpoint->udp, address, length);
  mutex_unlock(&endpoint->lane);
  return result;
}

References ERROR_INVALID_PARAM, quic_endpoint::lane, quic_udp_endpoint_address(), SET_ERRNO, and quic_endpoint::udp.

quic_endpoint_destroy()

asciichat_error_t quic_endpoint_destroy

(

quic_endpoint_t **

endpoint

)

Stop must succeed and all claimed transports must be destroyed first. Lifecycle calls and destruction must not run concurrently with other calls.

Definition at line 353 of file endpoint.c.

                                                                    {
  if (!endpoint || !*endpoint)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC endpoint destruction");
  if (!(*endpoint)->stopped || (*endpoint)->count)
    return SET_ERRNO(ERROR_INVALID_STATE, "Stop QUIC endpoint and release all transports first");
  quic_udp_endpoint_destroy(&(*endpoint)->udp);
  quic_tls_destroy(&(*endpoint)->tls);
  mutex_destroy(&(*endpoint)->lane);
  SAFE_FREE(*endpoint);
  *endpoint = NULL;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, quic_tls_destroy(), quic_udp_endpoint_destroy(), SAFE_FREE, and SET_ERRNO.

Referenced by api_server_main(), network_connection_open(), and session_quic_listeners_close().

quic_endpoint_migrate()

asciichat_error_t quic_endpoint_migrate	(	quic_endpoint_t *	endpoint,
		const struct sockaddr *	local_address,
		socklen_t	length )

Move a single-connection client endpoint to a new concrete local address. Port zero requests a new ephemeral port. TLS, ACIP keys, and stream state survive; ngtcp2 validates the new path after the immediate switch. Migration requires handshake confirmation, a spare peer CID, and peer permission. Pause transport users first, as for endpoint lifecycle calls. This call stops and restarts the worker to avoid closing a socket under its readiness wait. A rejected migration retains the original socket and live connection. The new address must have the same family as the existing remote address.

Definition at line 366 of file endpoint.c.

                                                          {
  if (!endpoint || endpoint->listener || !local_address)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC client endpoint migration");
  mutex_lock(&endpoint->lane);
  bool available = !endpoint->stopping && !endpoint->terminal_error && endpoint->count == 1 &&
                   endpoint->transports->connection && endpoint->worker;
  mutex_unlock(&endpoint->lane);
  if (!available)
    return SET_ERRNO(ERROR_INVALID_STATE, "QUIC migration requires one live client connection");
  asciichat_error_t result = quic_worker_stop(&endpoint->worker);
  if (result != ASCIICHAT_OK)
    return result;
  mutex_lock(&endpoint->lane);
  result = quic_udp_migrate(endpoint->udp, local_address, length, time_get_ns());
  asciichat_error_t restart =
      quic_worker_start_locked_failure(endpoint->udp, &endpoint->lane, connection_failed, endpoint, &endpoint->worker);
  if (restart != ASCIICHAT_OK)
    (void)connection_failed(NULL, restart, endpoint);
  mutex_unlock(&endpoint->lane);
  return restart != ASCIICHAT_OK ? restart : result;
}

References ASCIICHAT_OK, endpoint_transport::connection, quic_endpoint::count, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, quic_endpoint::lane, quic_endpoint::listener, quic_udp_migrate(), quic_worker_start_locked_failure(), quic_worker_stop(), SET_ERRNO, quic_endpoint::stopping, quic_endpoint::terminal_error, quic_endpoint::transports, quic_endpoint::udp, and quic_endpoint::worker.

quic_endpoint_open()

asciichat_error_t quic_endpoint_open	(	const struct sockaddr *	bind_address,
		socklen_t	bind_length,
		bool	listener,
		const quic_config_t *	config,
		quic_endpoint_t **	out )

Bind a concrete IPv4 or IPv6 local address and start the endpoint worker. Configuration strings are consumed during this call. The caller retains address storage. A listener requires a matching certificate and key.

Definition at line 131 of file endpoint.c.

                                                                                         {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC endpoint output");
  *out = NULL;
  if (!address || !config)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC endpoint configuration");
  quic_endpoint_t *endpoint = SAFE_CALLOC(1, sizeof(*endpoint), quic_endpoint_t *);
  if (!endpoint)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate QUIC endpoint");
  if (mutex_init(&endpoint->lane, "quic_endpoint") != 0) {
    SAFE_FREE(endpoint);
    return SET_ERRNO(ERROR_THREAD, "Cannot initialize QUIC endpoint lane");
  }
  bool webtransport = config->webtransport_origin || config->webtransport_path;
  bool http3 = webtransport || config->enable_http3 || config->http_server;
  if (http3 && config->alpn && strcmp(config->alpn, "h3") != 0) {
    mutex_destroy(&endpoint->lane);
    SAFE_FREE(endpoint);
    return SET_ERRNO(ERROR_INVALID_PARAM, "HTTP/3 requires the h3 ALPN");
  }
  if (webtransport &&
      (!listener || !config->enable_datagrams || !config->webtransport_origin || !config->webtransport_path ||
       strncmp(config->webtransport_origin, "https://", sizeof("https://") - 1) != 0 ||
       config->webtransport_path[0] != '/' ||
       strnlen(config->webtransport_origin, sizeof(endpoint->tls->webtransport_origin)) >=
           sizeof(endpoint->tls->webtransport_origin) ||
       strnlen(config->webtransport_path, sizeof(endpoint->tls->webtransport_path)) >=
           sizeof(endpoint->tls->webtransport_path) ||
       (config->alpn && strcmp(config->alpn, "h3") != 0))) {
    mutex_destroy(&endpoint->lane);
    SAFE_FREE(endpoint);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid WebTransport listener configuration");
  }
  const char *alpn = config->alpn ? config->alpn : http3 ? "h3" : "acip/1";
  asciichat_error_t result =
      listener ? quic_tls_server_create(alpn, config->certificate_file, config->private_key_file, &endpoint->tls)
               : quic_tls_client_create(alpn, config->ca_file, &endpoint->tls);
  if (result == ASCIICHAT_OK) {
    endpoint->tls->enable_datagrams = config->enable_datagrams;
    endpoint->tls->webtransport = webtransport;
    endpoint->tls->http3 = http3;
    endpoint->tls->accept_native = webtransport && config->accept_native;
    endpoint->tls->http_server = config->http_server;
    if (endpoint->tls->accept_native) {
      static const unsigned char protocols[] = {2, 'h', '3', 6, 'a', 'c', 'i', 'p', '/', '1'};
      memcpy(endpoint->tls->alpn, protocols, sizeof(protocols));
      endpoint->tls->alpn_length = sizeof(protocols);
    }
    if (webtransport) {
      memcpy(endpoint->tls->webtransport_origin, config->webtransport_origin,
             strlen(config->webtransport_origin) + (size_t)1);
      memcpy(endpoint->tls->webtransport_path, config->webtransport_path,
             strlen(config->webtransport_path) + (size_t)1);
    }
    endpoint->prefer_audio_datagrams = config->prefer_audio_datagrams;
    endpoint->prefer_visual_datagrams = config->prefer_visual_datagrams;
    endpoint->listener = listener;
    result = quic_udp_endpoint_create(address, length, listener ? endpoint->tls : NULL,
                                      listener ? accept_connection : NULL, listener ? endpoint : NULL, &endpoint->udp);
  }
  if (result == ASCIICHAT_OK)
    result = quic_worker_start_locked_failure(endpoint->udp, &endpoint->lane, connection_failed, endpoint,
                                              &endpoint->worker);
  if (result != ASCIICHAT_OK) {
    quic_udp_endpoint_destroy(&endpoint->udp);
    quic_tls_destroy(&endpoint->tls);
    mutex_destroy(&endpoint->lane);
    SAFE_FREE(endpoint);
    return result;
  }
  *out = endpoint;
  return ASCIICHAT_OK;
}

References quic_config_t::accept_native, quic_tls_t::accept_native, quic_config_t::alpn, quic_tls_t::alpn, quic_tls_t::alpn_length, ASCIICHAT_OK, quic_config_t::ca_file, quic_config_t::certificate_file, quic_config_t::enable_datagrams, quic_tls_t::enable_datagrams, quic_config_t::enable_http3, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_THREAD, quic_tls_t::http3, quic_config_t::http_server, quic_tls_t::http_server, quic_endpoint::lane, quic_endpoint::listener, out, quic_config_t::prefer_audio_datagrams, quic_endpoint::prefer_audio_datagrams, quic_config_t::prefer_visual_datagrams, quic_endpoint::prefer_visual_datagrams, quic_config_t::private_key_file, quic_tls_client_create(), quic_tls_destroy(), quic_tls_server_create(), quic_udp_endpoint_create(), quic_udp_endpoint_destroy(), quic_worker_start_locked_failure(), SAFE_CALLOC, SAFE_FREE, SET_ERRNO, quic_endpoint::tls, quic_endpoint::udp, quic_tls_t::webtransport, quic_config_t::webtransport_origin, quic_tls_t::webtransport_origin, quic_config_t::webtransport_path, quic_tls_t::webtransport_path, and quic_endpoint::worker.

Referenced by api_server_main(), and session_quic_listeners_open().

quic_endpoint_set_http_server()

asciichat_error_t quic_endpoint_set_http_server	(	quic_endpoint_t *	endpoint,
		http_server_t *	server )

Attach the shared HTTP handler before accepting new HTTP/3 streams.

Definition at line 206 of file endpoint.c.

                                                                                                  {
  if (!endpoint || !endpoint->listener || !endpoint->tls || !endpoint->tls->http3)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Endpoint is not an HTTP/3 listener");
  mutex_lock(&endpoint->lane);
  asciichat_error_t result = ASCIICHAT_OK;
  if (endpoint->stopping || endpoint->count)
    result = SET_ERRNO(ERROR_INVALID_STATE, "HTTP/3 handler must be attached before connections");
  else
    endpoint->tls->http_server = server;
  mutex_unlock(&endpoint->lane);
  return result;
}

References ASCIICHAT_OK, quic_endpoint::count, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, quic_tls_t::http3, quic_tls_t::http_server, quic_endpoint::lane, quic_endpoint::listener, SET_ERRNO, quic_endpoint::stopping, and quic_endpoint::tls.

quic_endpoint_stop()

asciichat_error_t quic_endpoint_stop

(

quic_endpoint_t *

endpoint

)

Stop and join the worker and interrupt remaining transports. Unclaimed accepts are discarded. Claimed transports must still be destroyed.

Definition at line 308 of file endpoint.c.

                                                                {
  if (!endpoint)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC endpoint");
  if (endpoint->stopped)
    return ASCIICHAT_OK;
  mutex_lock(&endpoint->lane);
  endpoint->stopping = true;
  mutex_unlock(&endpoint->lane);
  asciichat_error_t worker_result = endpoint->worker ? quic_worker_stop(&endpoint->worker) : ASCIICHAT_OK;
  if (endpoint->worker)
    return worker_result;
  asciichat_error_t result = ASCIICHAT_OK;
  for (;;) {
    mutex_lock(&endpoint->lane);
    endpoint_transport_t *item = endpoint->transports;
    while (item && item->claimed)
      item = item->next;
    if (item)
      item->claimed = true;
    mutex_unlock(&endpoint->lane);
    if (!item)
      break;
    acip_transport_t *transport = item->transport;
    result = quic_release(endpoint, &transport);
    if (result != ASCIICHAT_OK)
      return result;
  }
  mutex_lock(&endpoint->lane);
  for (endpoint_transport_t *item = endpoint->transports; item; item = item->next) {
    result = quic_transport_fail_on_lane(item->transport, ERROR_NETWORK);
    if (result != ASCIICHAT_OK)
      break;
    if (item->connection) {
      result = quic_udp_remove(endpoint->udp, item->connection);
      if (result != ASCIICHAT_OK)
        break;
      item->connection = NULL;
    }
  }
  if (result == ASCIICHAT_OK)
    endpoint->stopped = true;
  mutex_unlock(&endpoint->lane);
  return result == ASCIICHAT_OK ? worker_result : result;
}

References ASCIICHAT_OK, endpoint_transport::claimed, endpoint_transport::connection, ERROR_INVALID_PARAM, ERROR_NETWORK, quic_endpoint::lane, endpoint_transport::next, quic_release(), quic_transport_fail_on_lane(), quic_udp_remove(), quic_worker_stop(), SET_ERRNO, quic_endpoint::stopped, quic_endpoint::stopping, endpoint_transport::transport, quic_endpoint::transports, quic_endpoint::udp, and quic_endpoint::worker.

Referenced by api_server_main(), network_connection_open(), and session_quic_listeners_close().

quic_release()

asciichat_error_t quic_release	(	quic_endpoint_t *	endpoint,
		acip_transport_t **	transport )

Stop all users, then release through the endpoint, or destroy the transport directly using acip_transport_destroy. The endpoint must outlive it.

Definition at line 280 of file endpoint.c.

                                                                                        {
  if (!endpoint || !transport || !*transport)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC transport release");
  mutex_lock(&endpoint->lane);
  endpoint_transport_t **link = &endpoint->transports;
  while (*link && (*link)->transport != *transport)
    link = &(*link)->next;
  if (!*link || !(*link)->claimed) {
    mutex_unlock(&endpoint->lane);
    return SET_ERRNO(ERROR_INVALID_PARAM, "Transport does not belong to QUIC endpoint");
  }
  endpoint_transport_t *item = *link;
  asciichat_error_t result = quic_transport_fail_on_lane(item->transport, ERROR_NETWORK);
  if (result == ASCIICHAT_OK && item->connection)
    result = quic_udp_remove(endpoint->udp, item->connection);
  if (result == ASCIICHAT_OK) {
    *link = item->next;
    --endpoint->count;
  }
  mutex_unlock(&endpoint->lane);
  if (result != ASCIICHAT_OK)
    return result;
  acip_transport_destroy(item->transport);
  SAFE_FREE(item);
  *transport = NULL;
  return ASCIICHAT_OK;
}

References acip_transport_destroy(), ASCIICHAT_OK, endpoint_transport::claimed, endpoint_transport::connection, quic_endpoint::count, ERROR_INVALID_PARAM, ERROR_NETWORK, quic_endpoint::lane, endpoint_transport::next, quic_transport_fail_on_lane(), quic_udp_remove(), SAFE_FREE, SET_ERRNO, endpoint_transport::transport, quic_endpoint::transports, and quic_endpoint::udp.

Referenced by quic_endpoint_stop().

quic_transport_allow_media()

asciichat_error_t quic_transport_allow_media

(

acip_transport_t *

transport

)

Definition at line 378 of file quic/transport.c.

                                                                          {
  if (!transport || transport->methods != &quic_methods)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC transport");
  quic_transport_t *quic = transport->impl_data;
  lane_lock(quic);
  asciichat_error_t result = quic->connected ? quic_connection_allow_media(quic->connection)
                                             : SET_ERRNO(quic->failure, "QUIC transport is closed");
  lane_unlock(quic);
  return result;
}

References quic_transport_t::connected, quic_transport_t::connection, ERROR_INVALID_PARAM, quic_transport_t::failure, acip_transport::impl_data, acip_transport::methods, quic_connection_allow_media(), and SET_ERRNO.

quic_transport_begin_security()

asciichat_error_t quic_transport_begin_security	(	acip_transport_t *	transport,
		crypto_context_t *	crypto )

Start the authenticated transition after the existing ACIP handshake. crypto is borrowed and must outlive the transport. After this call the caller must not access or rekey it until the transport has been released.

Definition at line 324 of file quic/transport.c.

                                                                                                       {
  if (!transport || transport->methods != &quic_methods || !crypto)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC transport security context");
  quic_transport_t *quic = transport->impl_data;
  lane_lock(quic);
  asciichat_error_t result = quic->connected ? quic_connection_enable_security(quic->connection, crypto)
                                             : SET_ERRNO(quic->failure, "QUIC transport is closed");
  if (result == ASCIICHAT_OK) {
    transport->crypto_ctx = crypto;
    result = acip_security_activate(transport);
    if (quic->wake)
      quic->wake(quic->wake_context);
  }
  lane_unlock(quic);
  if (result == ASCIICHAT_OK && quic->lane)
    result = acip_outbound_create(transport);
  return result;
}

References acip_outbound_create(), acip_security_activate(), ASCIICHAT_OK, quic_transport_t::connected, quic_transport_t::connection, acip_transport::crypto_ctx, ERROR_INVALID_PARAM, quic_transport_t::failure, acip_transport::impl_data, quic_transport_t::lane, acip_transport::methods, quic_connection_enable_security(), SET_ERRNO, quic_transport_t::wake, and quic_transport_t::wake_context.

quic_transport_peer_address()

asciichat_error_t quic_transport_peer_address	(	acip_transport_t *	transport,
		struct sockaddr_storage *	address,
		socklen_t *	length )

Copy the current peer address. It may change after a validated migration.

Definition at line 52 of file quic/transport.c.

                                                                 {
  if (!transport || transport->methods != &quic_methods || !address || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC peer address query");
  quic_transport_t *quic = transport->impl_data;
  if (quic->lane)
    mutex_lock(quic->lane);
  asciichat_error_t result = quic->connected ? quic_connection_peer_address(quic->connection, address, length)
                                             : SET_ERRNO(quic->failure, "QUIC transport is closed");
  if (quic->lane)
    mutex_unlock(quic->lane);
  return result;
}

References quic_transport_t::connected, quic_transport_t::connection, ERROR_INVALID_PARAM, quic_transport_t::failure, acip_transport::impl_data, quic_transport_t::lane, acip_transport::methods, quic_connection_peer_address(), and SET_ERRNO.

quic_transport_security_ready()

bool quic_transport_security_ready

(

acip_transport_t *

transport

)

Definition at line 343 of file quic/transport.c.

                                                                {
  if (!transport || transport->methods != &quic_methods)
    return false;
  quic_transport_t *quic = transport->impl_data;
  lane_lock(quic);
  bool ready = quic->connected && quic_connection_security_ready(quic->connection);
  lane_unlock(quic);
  return ready;
}

References quic_transport_t::connected, quic_transport_t::connection, acip_transport::impl_data, acip_transport::methods, and quic_connection_security_ready().

quic_transport_wait_security()

asciichat_error_t quic_transport_wait_security	(	acip_transport_t *	transport,
		uint64_t	timeout_ns )

Wait at most timeout_ns for the authenticated readiness exchange.

Definition at line 353 of file quic/transport.c.

                                                                                                 {
  if (!transport || transport->methods != &quic_methods)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC transport");
  quic_transport_t *quic = transport->impl_data;
  if (!quic->lane)
    return SET_ERRNO(ERROR_NOT_SUPPORTED, "QUIC security wait requires a serialized endpoint");
  uint64_t start = time_get_ns();
  lane_lock(quic);
  while (quic->connected && !quic_connection_security_ready(quic->connection)) {
    uint64_t elapsed = time_get_ns() - start;
    if (elapsed >= timeout_ns) {
      lane_unlock(quic);
      return SET_ERRNO(ERROR_NETWORK_TIMEOUT, "QUIC security readiness timed out");
    }
    int rc = cond_timedwait(&quic->security_changed, quic->lane, timeout_ns - elapsed);
    if (rc != 0 && rc != ETIMEDOUT) {
      lane_unlock(quic);
      return SET_ERRNO(ERROR_THREAD, "QUIC security readiness wait failed");
    }
  }
  asciichat_error_t result = quic->connected ? ASCIICHAT_OK : SET_ERRNO(quic->failure, "QUIC transport is closed");
  lane_unlock(quic);
  return result;
}

References ASCIICHAT_OK, quic_transport_t::connected, quic_transport_t::connection, ERROR_INVALID_PARAM, ERROR_NETWORK_TIMEOUT, ERROR_NOT_SUPPORTED, ERROR_THREAD, ETIMEDOUT, quic_transport_t::failure, acip_transport::impl_data, quic_transport_t::lane, acip_transport::methods, quic_connection_security_ready(), quic_transport_t::security_changed, and SET_ERRNO.