udp.c File Reference

Go to the source code of this file.

Data Structures
struct	udp_peer
	acip quic udp endpoint is intentionally a small, concrete record. Fields such as socket, local, local_length, server_tls give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. More...
struct	quic_udp_endpoint

Macros
#define	QUIC_UDP_CID_LENGTH   16
#define	QUIC_UDP_PACKET_CAPACITY   1452
#define	QUIC_UDP_MAX_CONNECTIONS   64
#define	QUIC_UDP_READ_BATCH   128
#define	QUIC_UDP_WRITE_BATCH   16
#define	QUIC_RETRY_SECRET_LENGTH   32
#define	QUIC_RETRY_TOKEN_LIFETIME   (10ULL * 1000000000ULL)

Typedefs
typedef struct udp_peer	udp_peer_t
	acip quic udp endpoint is intentionally a small, concrete record. Fields such as socket, local, local_length, server_tls give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed.

Functions
asciichat_error_t	quic_udp_endpoint_create (const struct sockaddr *address, socklen_t 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)
asciichat_error_t	quic_udp_pump (quic_udp_endpoint_t *endpoint, uint64_t now, quic_connection_t **failed)
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)
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)
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)
asciichat_error_t	quic_udp_migrate (quic_udp_endpoint_t *endpoint, const struct sockaddr *address, socklen_t length, uint64_t now_ns)

Macro Definition Documentation

QUIC_RETRY_SECRET_LENGTH

#define QUIC_RETRY_SECRET_LENGTH   32

Definition at line 14 of file udp.c.

QUIC_RETRY_TOKEN_LIFETIME

#define QUIC_RETRY_TOKEN_LIFETIME   (10ULL * 1000000000ULL)

Definition at line 15 of file udp.c.

QUIC_UDP_CID_LENGTH

#define QUIC_UDP_CID_LENGTH   16

Definition at line 9 of file udp.c.

QUIC_UDP_MAX_CONNECTIONS

#define QUIC_UDP_MAX_CONNECTIONS   64

Definition at line 11 of file udp.c.

QUIC_UDP_PACKET_CAPACITY

#define QUIC_UDP_PACKET_CAPACITY   1452

Definition at line 10 of file udp.c.

Referenced by quic_udp_close_peer().

QUIC_UDP_READ_BATCH

#define QUIC_UDP_READ_BATCH   128

Definition at line 12 of file udp.c.

Referenced by quic_udp_pump().

QUIC_UDP_WRITE_BATCH

#define QUIC_UDP_WRITE_BATCH   16

Definition at line 13 of file udp.c.

Referenced by quic_udp_pump().

Typedef Documentation

udp_peer_t

typedef struct udp_peer udp_peer_t

acip quic udp endpoint is intentionally a small, concrete record. Fields such as socket, local, local_length, server_tls give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed.

The useful part of udp peer is in next, connection, pending_path, pending_length: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.

Function Documentation

quic_udp_close_peer()

asciichat_error_t quic_udp_close_peer	(	quic_udp_endpoint_t *	endpoint,
		quic_connection_t *	connection )

Definition at line 339 of file udp.c.

                                                                                                    {
  if (!quic_udp_contains(endpoint, connection))
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC UDP connection is not owned by endpoint");
  uint8_t packet[QUIC_UDP_PACKET_CAPACITY];
  ngtcp2_path_storage path;
  size_t length = 0;
  asciichat_error_t result =
      quic_connection_write_close(connection, &path, packet, sizeof(packet), &length, time_get_ns());
  if (result != ASCIICHAT_OK || !length)
    return result;
  ngtcp2_addr *remote = &path.path.remote;
  ssize_t sent = socket_sendto(endpoint->socket, packet, length, 0, remote->addr, (socklen_t)remote->addrlen);
  if (sent < 0 || (size_t)sent != length)
    return SET_ERRNO(ERROR_NETWORK, "Cannot send QUIC close packet");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK, quic_connection_write_close(), quic_udp_contains(), QUIC_UDP_PACKET_CAPACITY, SET_ERRNO, and quic_udp_endpoint::socket.

quic_udp_connect()

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 )

Definition at line 144 of file udp.c.

                                                            {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC UDP connection output");
  *out = NULL;
  if (!endpoint || !client_tls || client_tls->server || !valid_sockaddr(remote, remote_length) ||
      remote->sa_family != ((struct sockaddr *)&endpoint->local)->sa_family)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC UDP connection configuration");
  udp_peer_t *peer = new_peer(endpoint);
  if (!peer)
    return SET_ERRNO(ERROR_BUFFER_FULL, "QUIC UDP connection limit reached or allocation failed");
  ngtcp2_path path = make_path(endpoint, remote, remote_length);
  asciichat_error_t result = quic_connection_client_create(client_tls, server_name, &path, now_ns, &peer->connection);
  if (result != ASCIICHAT_OK) {
    SAFE_FREE(peer);
    return result;
  }
  add_peer(endpoint, peer);
  *out = peer->connection;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, udp_peer::connection, ERROR_BUFFER_FULL, ERROR_INVALID_PARAM, quic_udp_endpoint::local, out, quic_connection_client_create(), SAFE_FREE, quic_tls_t::server, and SET_ERRNO.

Referenced by quic_connect().

quic_udp_contains()

bool quic_udp_contains	(	const quic_udp_endpoint_t *	endpoint,
		const quic_connection_t *	connection )

Definition at line 330 of file udp.c.

                                                                                                 {
  if (!endpoint || !connection)
    return false;
  for (const udp_peer_t *peer = endpoint->peers; peer; peer = peer->next)
    if (peer->connection == connection)
      return true;
  return false;
}

References udp_peer::connection, udp_peer::next, and quic_udp_endpoint::peers.

Referenced by quic_udp_close_peer().

quic_udp_endpoint_address()

asciichat_error_t quic_udp_endpoint_address	(	const quic_udp_endpoint_t *	endpoint,
		struct sockaddr_storage *	address,
		socklen_t *	length )

Definition at line 106 of file udp.c.

                                                               {
  if (!endpoint || !address || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC UDP address output");
  *address = endpoint->local;
  *length = endpoint->local_length;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, quic_udp_endpoint::local, quic_udp_endpoint::local_length, and SET_ERRNO.

Referenced by quic_endpoint_address().

quic_udp_endpoint_create()

asciichat_error_t quic_udp_endpoint_create	(	const struct sockaddr *	address,
		socklen_t	length,
		quic_tls_t *	server_tls,
		quic_udp_accept_fn	accept,
		void *	context,
		quic_udp_endpoint_t **	out )

Definition at line 67 of file udp.c.

                                                                                                                {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing QUIC UDP endpoint output");
  *out = NULL;
  if (!valid_sockaddr(address, length) || (!!server_tls != !!accept) || (server_tls && !server_tls->server))
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC UDP requires a concrete bind address and valid listener");
  quic_udp_endpoint_t *endpoint = SAFE_CALLOC(1, sizeof(*endpoint), quic_udp_endpoint_t *);
  if (!endpoint)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate QUIC UDP endpoint");
  endpoint->socket = socket_create("quic_udp", address->sa_family, SOCK_DGRAM, 0);
  if (endpoint->socket == INVALID_SOCKET_VALUE || socket_bind(endpoint->socket, address, length) != 0 ||
      socket_set_nonblocking(endpoint->socket, true) != 0) {
    if (endpoint->socket != INVALID_SOCKET_VALUE)
      socket_close(endpoint->socket);
    SAFE_FREE(endpoint);
    return SET_ERRNO(ERROR_NETWORK, "Cannot bind QUIC UDP endpoint");
  }
  endpoint->local_length = sizeof(endpoint->local);
  if (socket_getsockname(endpoint->socket, (struct sockaddr *)&endpoint->local, &endpoint->local_length) != 0) {
    socket_close(endpoint->socket);
    SAFE_FREE(endpoint);
    return SET_ERRNO(ERROR_NETWORK, "Cannot obtain QUIC UDP endpoint address");
  }
  endpoint->server_tls = server_tls;
  if (server_tls) {
    if (sodium_init() < 0) {
      socket_close(endpoint->socket);
      SAFE_FREE(endpoint);
      return SET_ERRNO(ERROR_CRYPTO, "Cannot initialize QUIC Retry token secret");
    }
    randombytes_buf(endpoint->retry_secret, sizeof(endpoint->retry_secret));
  }
  endpoint->accept = accept;
  endpoint->context = context;
  *out = endpoint;
  return ASCIICHAT_OK;
}

References quic_udp_endpoint::accept, ASCIICHAT_OK, quic_udp_endpoint::context, ERROR_CRYPTO, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK, quic_udp_endpoint::local, quic_udp_endpoint::local_length, out, quic_udp_endpoint::retry_secret, SAFE_CALLOC, SAFE_FREE, quic_tls_t::server, quic_udp_endpoint::server_tls, SET_ERRNO, and quic_udp_endpoint::socket.

Referenced by quic_endpoint_open(), and quic_udp_migrate().

quic_udp_endpoint_destroy()

void quic_udp_endpoint_destroy

(

quic_udp_endpoint_t **

endpoint

)

Definition at line 372 of file udp.c.

                                                               {
  if (!endpoint || !*endpoint)
    return;
  while ((*endpoint)->peers)
    (void)quic_udp_remove(*endpoint, (*endpoint)->peers->connection);
  socket_close((*endpoint)->socket);
  sodium_memzero((*endpoint)->retry_secret, sizeof((*endpoint)->retry_secret));
  SAFE_FREE(*endpoint);
  *endpoint = NULL;
}

References udp_peer::connection, quic_udp_endpoint::peers, quic_udp_remove(), and SAFE_FREE.

Referenced by quic_endpoint_destroy(), quic_endpoint_open(), and quic_udp_migrate().

quic_udp_migrate()

asciichat_error_t quic_udp_migrate	(	quic_udp_endpoint_t *	endpoint,
		const struct sockaddr *	address,
		socklen_t	length,
		uint64_t	now_ns )

Definition at line 383 of file udp.c.

                                                    {
  if (!endpoint || endpoint->server_tls || endpoint->count != 1 || !valid_sockaddr(address, length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC migration requires a single client connection and concrete address");
  if (endpoint->peers->pending_length)
    return SET_ERRNO(ERROR_BUFFER_FULL, "Flush the pending UDP packet before migrating");
  quic_udp_endpoint_t *candidate = NULL;
  asciichat_error_t result = quic_udp_endpoint_create(address, length, NULL, NULL, NULL, &candidate);
  if (result != ASCIICHAT_OK)
    return result;
  result = quic_connection_migrate(endpoint->peers->connection, (struct sockaddr *)&candidate->local,
                                   candidate->local_length, now_ns);
  if (result == ASCIICHAT_OK) {
    socket_t old_socket = endpoint->socket;
    endpoint->socket = candidate->socket;
    candidate->socket = old_socket;
    endpoint->local = candidate->local;
    endpoint->local_length = candidate->local_length;
  }
  quic_udp_endpoint_destroy(&candidate);
  return result;
}

References ASCIICHAT_OK, udp_peer::connection, quic_udp_endpoint::count, ERROR_BUFFER_FULL, ERROR_INVALID_PARAM, quic_udp_endpoint::local, quic_udp_endpoint::local_length, quic_udp_endpoint::peers, udp_peer::pending_length, quic_connection_migrate(), quic_udp_endpoint_create(), quic_udp_endpoint_destroy(), quic_udp_endpoint::server_tls, SET_ERRNO, and quic_udp_endpoint::socket.

Referenced by quic_endpoint_migrate().

quic_udp_pump()

asciichat_error_t quic_udp_pump	(	quic_udp_endpoint_t *	endpoint,
		uint64_t	now,
		quic_connection_t **	failed )

Definition at line 222 of file udp.c.

                                                                                                         {
  if (!endpoint || !failed)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC UDP pump arguments");
  *failed = NULL;
  for (unsigned i = 0; i < QUIC_UDP_READ_BATCH; ++i) {
    uint8_t data[65536];
    struct sockaddr_storage remote = {0};
    socklen_t remote_length = sizeof(remote);
    ssize_t received =
        socket_recvfrom(endpoint->socket, data, sizeof(data), 0, (struct sockaddr *)&remote, &remote_length);
    if (received < 0) {
      int error = socket_get_last_error();
      if (socket_is_would_block_error(error))
        break;
      /* An ICMP error for an earlier datagram does not identify a QUIC
       * connection and must not terminate a shared listener. */
      if (socket_is_connection_reset_error(error))
        continue;
      return SET_ERRNO(ERROR_NETWORK, "QUIC UDP receive failed");
    }
    if (!received || !valid_sockaddr((struct sockaddr *)&remote, remote_length))
      continue;
    asciichat_error_t result =
        receive_one(endpoint, data, (size_t)received, (struct sockaddr *)&remote, remote_length, now, failed);
    if (result != ASCIICHAT_OK)
      return result;
  }
  for (udp_peer_t *peer = endpoint->peers; peer; peer = peer->next) {
    if (quic_connection_expiry(peer->connection) <= now) {
      asciichat_error_t result = quic_connection_handle_expiry(peer->connection, now);
      if (result != ASCIICHAT_OK) {
        *failed = peer->connection;
        return result;
      }
    }
    for (unsigned i = 0; i < QUIC_UDP_WRITE_BATCH; ++i) {
      if (!peer->pending_length) {
        asciichat_error_t result = quic_connection_write(peer->connection, &peer->pending_path, peer->pending,
                                                         sizeof(peer->pending), &peer->pending_length, now);
        if (result != ASCIICHAT_OK) {
          *failed = peer->connection;
          return result;
        }
        if (!peer->pending_length)
          break;
      }
      ngtcp2_addr *remote = &peer->pending_path.path.remote;
      ssize_t sent = socket_sendto(endpoint->socket, peer->pending, peer->pending_length, 0, remote->addr,
                                   (socklen_t)remote->addrlen);
      if (sent < 0 && socket_is_would_block_error(socket_get_last_error()))
        break;
      if (sent < 0 || (size_t)sent != peer->pending_length)
        return SET_ERRNO(ERROR_NETWORK, "QUIC UDP send failed");
      peer->pending_length = 0;
      asciichat_error_t result = quic_connection_packet_sent(peer->connection, now);
      if (result != ASCIICHAT_OK) {
        *failed = peer->connection;
        return result;
      }
    }
  }
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, udp_peer::connection, ERROR_INVALID_PARAM, ERROR_NETWORK, udp_peer::next, quic_udp_endpoint::peers, udp_peer::pending, udp_peer::pending_length, udp_peer::pending_path, quic_connection_expiry(), quic_connection_handle_expiry(), quic_connection_packet_sent(), quic_connection_write(), QUIC_UDP_READ_BATCH, QUIC_UDP_WRITE_BATCH, SET_ERRNO, and quic_udp_endpoint::socket.

quic_udp_remove()

asciichat_error_t quic_udp_remove	(	quic_udp_endpoint_t *	endpoint,
		quic_connection_t *	connection )

Definition at line 356 of file udp.c.

                                                                                                {
  if (!endpoint || !connection)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC UDP removal");
  udp_peer_t **next = &endpoint->peers;
  while (*next && (*next)->connection != connection)
    next = &(*next)->next;
  if (!*next)
    return SET_ERRNO(ERROR_INVALID_PARAM, "QUIC UDP connection is not owned by endpoint");
  udp_peer_t *peer = *next;
  *next = peer->next;
  --endpoint->count;
  quic_connection_destroy(&peer->connection);
  SAFE_FREE(peer);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, udp_peer::connection, quic_udp_endpoint::count, ERROR_INVALID_PARAM, udp_peer::next, quic_udp_endpoint::peers, quic_connection_destroy(), SAFE_FREE, and SET_ERRNO.

Referenced by quic_connect(), quic_endpoint_stop(), quic_release(), and quic_udp_endpoint_destroy().

quic_udp_wait()

asciichat_error_t quic_udp_wait	(	quic_udp_endpoint_t *	endpoint,
		uint64_t	wait_ns,
		bool	want_write,
		bool *	ready )

Definition at line 304 of file udp.c.

                                                                                                               {
  if (!endpoint || !ready)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC UDP wait");
  *ready = false;
  struct pollfd fd = {.fd = endpoint->socket, .events = (short)(POLLIN | (want_write ? POLLOUT : 0))};
  int64_t timeout = wait_ns > INT64_MAX ? INT64_MAX : (int64_t)wait_ns;
  int result = socket_poll(&fd, 1, timeout);
  if (result < 0)
    return SET_ERRNO(ERROR_NETWORK, "QUIC UDP poll failed");
  if (result > 0 && (fd.revents & (POLLERR | POLLNVAL)))
    return SET_ERRNO(ERROR_NETWORK, "QUIC UDP socket poll reported an error");
  *ready = result > 0;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK, SET_ERRNO, and quic_udp_endpoint::socket.

quic_udp_wait_parameters()

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 )

Definition at line 286 of file udp.c.

                                                                                                          {
  if (!endpoint || !wait_ns || !want_write || now_ns == UINT64_MAX)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC UDP wait parameters");
  *wait_ns = maximum_wait_ns;
  *want_write = false;
  for (const udp_peer_t *peer = endpoint->peers; peer; peer = peer->next) {
    uint64_t expiry = quic_connection_expiry(peer->connection);
    if (expiry <= now_ns)
      *wait_ns = 0;
    else if (expiry != UINT64_MAX && expiry - now_ns < *wait_ns)
      *wait_ns = expiry - now_ns;
    if (peer->pending_length)
      *want_write = true;
  }
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, udp_peer::connection, ERROR_INVALID_PARAM, udp_peer::next, quic_udp_endpoint::peers, udp_peer::pending_length, quic_connection_expiry(), and SET_ERRNO.

quic_udp_wake()

asciichat_error_t quic_udp_wake

(

quic_udp_endpoint_t *

endpoint

)

Definition at line 319 of file udp.c.

                                                               {
  if (!endpoint)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid QUIC UDP wake");
  const uint8_t wake = 0;
  ssize_t sent = socket_sendto(endpoint->socket, &wake, sizeof(wake), 0, (struct sockaddr *)&endpoint->local,
                               endpoint->local_length);
  if (sent != (ssize_t)sizeof(wake))
    return SET_ERRNO(ERROR_NETWORK, "Cannot wake QUIC UDP endpoint");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK, quic_udp_endpoint::local, quic_udp_endpoint::local_length, SET_ERRNO, and quic_udp_endpoint::socket.

Referenced by quic_worker_wake().