udp.h File Reference

Go to the source code of this file.

Typedefs
typedef struct quic_udp_endpoint	quic_udp_endpoint_t
typedef asciichat_error_t(*	quic_udp_accept_fn) (quic_connection_t *, void *)

Functions
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)
asciichat_error_t	quic_udp_pump (quic_udp_endpoint_t *endpoint, uint64_t now_ns, 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)

Typedef Documentation

quic_udp_accept_fn

typedef asciichat_error_t(* quic_udp_accept_fn) (quic_connection_t *, void *)

Definition at line 15 of file udp.h.

quic_udp_endpoint_t

typedef struct quic_udp_endpoint quic_udp_endpoint_t

Definition at line 14 of file udp.h.

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 *	bind_address,
		socklen_t	bind_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_ns,
		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().