lib/network/quic/connection.h

Go to the documentation of this file.

#pragma once
 
#include "stream.h"
#include "tls.h"
#include <ascii-chat/network/acip/security.h>
 
#include <libplatform/socket.h>
#include <ngtcp2/ngtcp2.h>
 
/* Private serialized connection engine. An endpoint owns and drives each
 * instance from one lane; it must not call these operations concurrently.
 * Times are nanoseconds on the time_get_ns() monotonic clock and cannot move
 * backwards. The TLS context and callback reference outlive the connection. */
typedef struct quic_connection quic_connection_t;
 
/* Produce a best-effort CONNECTION_CLOSE before an owned connection is
 * discarded. A zero-length result means that no close can be sent. */
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_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);
/* As above, after validating the Retry token and recovering its original DCID. */
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_receive(quic_connection_t *connection, const ngtcp2_path *path, const void *packet,
                                          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);
bool quic_connection_pending_packet_class(const quic_connection_t *connection, acip_traffic_class_t *traffic_class);
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_tls_ready(const quic_connection_t *connection);
/* A WebTransport listener is admitted only after its CONNECT is authorized. */
bool quic_connection_accept_ready(const quic_connection_t *connection);
bool quic_connection_webtransport_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);
/* Match an incoming destination CID, including the server's original Initial
 * CID. Called only on the connection lane. */
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_security_notifier(quic_connection_t *connection, void (*notify)(void *), void *context);
/* Notifier runs on the serialized lane and must not acquire the outbound queue lock. */
void quic_connection_set_keyframe_notifier(quic_connection_t *connection, void (*notify)(uint16_t, uint32_t, 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);
asciichat_error_t quic_connection_submit(quic_connection_t *connection, acip_traffic_class_t traffic_class,
                                         const void *packet, size_t length);
/* Maximum ACQD payload for the current path, or zero when unavailable. */
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 traffic_class, uint64_t deadline_ns);
asciichat_error_t quic_connection_submit_datagram(quic_connection_t *connection, acip_traffic_class_t traffic_class,
                                                  const void *packet, size_t length, uint64_t deadline_ns);
size_t quic_connection_pending_bytes(const quic_connection_t *connection);
/* Queue FIN after all previously admitted data for an open stream. No further
 * packets may be submitted to that class. ngtcp2 retransmits the FIN on loss. */
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);
void quic_connection_destroy(quic_connection_t **connection);
 
/* Client-only immediate migration after handshake confirmation. The new local
 * socket must already be bound; its owner keeps it alive for the connection. */
asciichat_error_t quic_connection_migrate(quic_connection_t *connection, const struct sockaddr *local, socklen_t length,
                                          uint64_t now_ns);