udp.h

Go to the documentation of this file.

#pragma once
 
#include "connection.h"
 
/* Private, single-lane UDP driver. The caller owns TLS contexts and must keep
 * them alive until after endpoint destruction. Accepted and connected handles
 * are borrowed from the endpoint and become invalid when removed or destroyed.
 * The accept callback runs on the pump lane before the Initial is processed;
 * it may install the packet receiver but must not reenter the endpoint.
 * Returning ERROR_BUFFER_FULL drops that Initial without stopping the listener;
 * other callback errors are reported to the endpoint owner. A callback must
 * decide whether to reject before attaching a transport, and must release any
 * other resources it created when returning an error. */
typedef struct quic_udp_endpoint quic_udp_endpoint_t;
typedef asciichat_error_t (*quic_udp_accept_fn)(quic_connection_t *, void *);
 
asciichat_error_t quic_udp_endpoint_create(const struct sockaddr *bind_address, socklen_t bind_length,
                                           quic_tls_t *server_tls, quic_udp_accept_fn accept, void *context,
                                           quic_udp_endpoint_t **out);
asciichat_error_t quic_udp_endpoint_address(const quic_udp_endpoint_t *endpoint, struct sockaddr_storage *address,
                                            socklen_t *length);
asciichat_error_t quic_udp_connect(quic_udp_endpoint_t *endpoint, quic_tls_t *client_tls, const char *server_name,
                                   const struct sockaddr *remote, socklen_t remote_length, uint64_t now_ns,
                                   quic_connection_t **out);
/* Nonblocking bounded work. A per-connection failure is returned with *failed
 * set to its borrowed handle; the caller may remove it and continue the other
 * connections. Socket-level failures leave *failed NULL. */
asciichat_error_t quic_udp_pump(quic_udp_endpoint_t *endpoint, uint64_t now_ns, quic_connection_t **failed);
/* After pumping, obtain the earliest timer and whether a socket-blocked
 * datagram needs write readiness. Call on the serialized endpoint lane. */
asciichat_error_t quic_udp_wait_parameters(const quic_udp_endpoint_t *endpoint, uint64_t now_ns,
                                           uint64_t maximum_wait_ns, uint64_t *wait_ns, bool *want_write);
/* Wait outside the endpoint lane. The owner must keep the endpoint/socket
 * alive until the wait and all wake calls have returned. A wake is coalescible
 * and must be followed by a pump; it carries no application data. */
asciichat_error_t quic_udp_wait(quic_udp_endpoint_t *endpoint, uint64_t wait_ns, bool want_write, bool *ready);
asciichat_error_t quic_udp_wake(quic_udp_endpoint_t *endpoint);
/* Test endpoint membership on its serialized lane without dereferencing the
 * supplied handle. Useful after an application failure callback removes it. */
bool quic_udp_contains(const quic_udp_endpoint_t *endpoint, const quic_connection_t *connection);
asciichat_error_t quic_udp_close_peer(quic_udp_endpoint_t *endpoint, quic_connection_t *connection);
asciichat_error_t quic_udp_remove(quic_udp_endpoint_t *endpoint, quic_connection_t *connection);
void quic_udp_endpoint_destroy(quic_udp_endpoint_t **endpoint);
 
/* Requires a stopped worker and a single client connection. A rejected
 * migration leaves the existing socket and endpoint address unchanged. */
asciichat_error_t quic_udp_migrate(quic_udp_endpoint_t *endpoint, const struct sockaddr *address, socklen_t length,
                                   uint64_t now_ns);