Quichex.Native.Nif (quichex v0.3.0)

View Source

Internal Rustler bindings. Prefer Quichex.Native for public usage.

Summary

Functions

Types

config()

@type config() :: reference()

connection()

@type connection() :: reference()

h3_config()

@type h3_config() :: reference()

h3_connection()

@type h3_connection() :: reference()

quic_binary()

@type quic_binary() :: binary()

reason()

@type reason() :: String.t()

stream_id()

@type stream_id() :: non_neg_integer()

Functions

config_discover_pmtu(config, enable)

@spec config_discover_pmtu(config(), boolean()) :: :ok | {:error, reason()}

config_enable_dgram(config, enabled, recv_queue_len, send_queue_len)

@spec config_enable_dgram(config(), boolean(), non_neg_integer(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_enable_early_data(config)

@spec config_enable_early_data(config()) :: :ok | {:error, reason()}

config_enable_hystart(config, enable)

@spec config_enable_hystart(config(), boolean()) :: :ok | {:error, reason()}

config_enable_pacing(config, enable)

@spec config_enable_pacing(config(), boolean()) :: :ok | {:error, reason()}

config_grease(config, enable)

@spec config_grease(config(), boolean()) :: :ok | {:error, reason()}

config_load_cert_chain_from_pem_file(config, path)

@spec config_load_cert_chain_from_pem_file(config(), String.t()) ::
  :ok | {:error, reason()}

config_load_priv_key_from_pem_file(config, path)

@spec config_load_priv_key_from_pem_file(config(), String.t()) ::
  :ok | {:error, reason()}

config_load_verify_locations_from_directory(config, path)

@spec config_load_verify_locations_from_directory(config(), String.t()) ::
  :ok | {:error, reason()}

config_load_verify_locations_from_file(config, path)

@spec config_load_verify_locations_from_file(config(), String.t()) ::
  :ok | {:error, reason()}

config_log_keys(config)

@spec config_log_keys(config()) :: :ok | {:error, reason()}

config_new(version)

@spec config_new(non_neg_integer()) :: {:ok, config()} | {:error, reason()}

config_set_ack_delay_exponent(config, value)

@spec config_set_ack_delay_exponent(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_active_connection_id_limit(config, value)

@spec config_set_active_connection_id_limit(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_application_protos(config, protos)

@spec config_set_application_protos(config(), [quic_binary()]) ::
  :ok | {:error, reason()}

config_set_cc_algorithm(config, algo)

@spec config_set_cc_algorithm(config(), String.t()) :: :ok | {:error, reason()}

config_set_disable_active_migration(config, disable)

@spec config_set_disable_active_migration(config(), boolean()) ::
  :ok | {:error, reason()}

config_set_disable_dcid_reuse(config, disable)

@spec config_set_disable_dcid_reuse(config(), boolean()) :: :ok | {:error, reason()}

config_set_initial_congestion_window_packets(config, value)

@spec config_set_initial_congestion_window_packets(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_initial_max_data(config, value)

@spec config_set_initial_max_data(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_initial_max_stream_data_bidi_local(config, value)

@spec config_set_initial_max_stream_data_bidi_local(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_initial_max_stream_data_bidi_remote(config, value)

@spec config_set_initial_max_stream_data_bidi_remote(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_initial_max_stream_data_uni(config, value)

@spec config_set_initial_max_stream_data_uni(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_initial_max_streams_bidi(config, value)

@spec config_set_initial_max_streams_bidi(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_initial_max_streams_uni(config, value)

@spec config_set_initial_max_streams_uni(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_ack_delay(config, value)

@spec config_set_max_ack_delay(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_amplification_factor(config, value)

@spec config_set_max_amplification_factor(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_connection_window(config, value)

@spec config_set_max_connection_window(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_datagram_frame_size(config, size)

@spec config_set_max_datagram_frame_size(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_idle_timeout(config, millis)

@spec config_set_max_idle_timeout(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_pacing_rate(config, value)

@spec config_set_max_pacing_rate(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_recv_udp_payload_size(config, size)

@spec config_set_max_recv_udp_payload_size(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_send_udp_payload_size(config, size)

@spec config_set_max_send_udp_payload_size(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_max_stream_window(config, value)

@spec config_set_max_stream_window(config(), non_neg_integer()) ::
  :ok | {:error, reason()}

config_set_stateless_reset_token(config, token)

@spec config_set_stateless_reset_token(config(), quic_binary()) ::
  :ok | {:error, reason()}

config_set_ticket_key(config, key)

@spec config_set_ticket_key(config(), quic_binary()) :: :ok | {:error, reason()}

config_verify_peer(config, verify)

@spec config_verify_peer(config(), boolean()) :: :ok | {:error, reason()}

connection_application_proto(conn)

@spec connection_application_proto(connection()) ::
  {:ok, quic_binary()} | {:error, reason()}

connection_close(conn, app, err, reason)

@spec connection_close(connection(), boolean(), non_neg_integer(), quic_binary()) ::
  :ok | {:error, reason()}

connection_destination_id(conn)

@spec connection_destination_id(connection()) ::
  {:ok, quic_binary()} | {:error, reason()}

connection_dgram_max_writable_len(conn)

@spec connection_dgram_max_writable_len(connection()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_dgram_recv(conn, max_len)

@spec connection_dgram_recv(connection(), non_neg_integer()) ::
  {:ok, quic_binary()} | {:error, reason()}

connection_dgram_recv_queue_byte_size(conn)

@spec connection_dgram_recv_queue_byte_size(connection()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_dgram_recv_queue_len(conn)

@spec connection_dgram_recv_queue_len(connection()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_dgram_send(conn, payload)

@spec connection_dgram_send(connection(), quic_binary()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_dgram_send_queue_byte_size(conn)

@spec connection_dgram_send_queue_byte_size(connection()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_dgram_send_queue_len(conn)

@spec connection_dgram_send_queue_len(connection()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_is_closed(conn)

@spec connection_is_closed(connection()) :: {:ok, boolean()} | {:error, reason()}

connection_is_draining(conn)

@spec connection_is_draining(connection()) :: {:ok, boolean()} | {:error, reason()}

connection_is_established(conn)

@spec connection_is_established(connection()) :: {:ok, boolean()} | {:error, reason()}

connection_is_in_early_data(conn)

@spec connection_is_in_early_data(connection()) ::
  {:ok, boolean()} | {:error, reason()}

connection_is_resumed(conn)

@spec connection_is_resumed(connection()) :: {:ok, boolean()} | {:error, reason()}

connection_is_server(conn)

@spec connection_is_server(connection()) :: {:ok, boolean()} | {:error, reason()}

connection_is_timed_out(conn)

@spec connection_is_timed_out(connection()) :: {:ok, boolean()} | {:error, reason()}

connection_local_error(conn)

@spec connection_local_error(connection()) ::
  {:ok, Quichex.Native.ConnectionError.t() | nil} | {:error, reason()}

connection_new_client(scid, server_name, local_addr, peer_addr, config, stream_recv_buffer_size)

@spec connection_new_client(
  quic_binary(),
  String.t() | nil,
  quic_binary(),
  quic_binary(),
  config(),
  non_neg_integer()
) :: {:ok, connection()} | {:error, reason()}

connection_new_server(scid, odcid, local_addr, peer_addr, config, stream_recv_buffer_size)

@spec connection_new_server(
  quic_binary(),
  quic_binary() | nil,
  quic_binary(),
  quic_binary(),
  config(),
  non_neg_integer()
) :: {:ok, connection()} | {:error, reason()}

connection_on_timeout(conn)

@spec connection_on_timeout(connection()) :: :ok | {:error, reason()}

connection_peer_cert(conn)

@spec connection_peer_cert(connection()) ::
  {:ok, quic_binary() | nil} | {:error, reason()}

connection_peer_error(conn)

@spec connection_peer_error(connection()) ::
  {:ok, Quichex.Native.ConnectionError.t() | nil} | {:error, reason()}

connection_peer_transport_params(conn)

@spec connection_peer_transport_params(connection()) ::
  {:ok, Quichex.Native.TransportParams.t() | nil} | {:error, reason()}

connection_readable_streams(conn)

@spec connection_readable_streams(connection()) ::
  {:ok, [stream_id()]} | {:error, reason()}

connection_recv(conn, packet, recv_info)

@spec connection_recv(connection(), quic_binary(), map()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_send(conn)

@spec connection_send(connection()) ::
  {:ok, {quic_binary(), map()}} | {:error, reason()}

connection_server_name(conn)

@spec connection_server_name(connection()) ::
  {:ok, String.t() | nil} | {:error, reason()}

connection_session(conn)

@spec connection_session(connection()) ::
  {:ok, quic_binary() | nil} | {:error, reason()}

connection_set_keylog_path(conn, path)

@spec connection_set_keylog_path(connection(), String.t()) :: :ok | {:error, reason()}

connection_set_session(conn, data)

@spec connection_set_session(connection(), quic_binary()) :: :ok | {:error, reason()}

connection_source_id(conn)

@spec connection_source_id(connection()) :: {:ok, quic_binary()} | {:error, reason()}

connection_stats(conn)

@spec connection_stats(connection()) ::
  {:ok, Quichex.Native.ConnectionStats.t()} | {:error, reason()}

connection_stream_finished(conn, stream_id)

@spec connection_stream_finished(connection(), stream_id()) ::
  {:ok, boolean()} | {:error, reason()}

connection_stream_recv(conn, stream_id, max_len)

@spec connection_stream_recv(connection(), stream_id(), non_neg_integer()) ::
  {:ok, {quic_binary(), boolean()}} | {:error, reason()}

connection_stream_send(conn, stream_id, data, fin)

@spec connection_stream_send(connection(), stream_id(), quic_binary(), boolean()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_stream_shutdown(conn, stream_id, direction, error_code)

@spec connection_stream_shutdown(
  connection(),
  stream_id(),
  String.t(),
  non_neg_integer()
) ::
  :ok | {:error, reason()}

connection_timeout(conn)

@spec connection_timeout(connection()) ::
  {:ok, non_neg_integer()} | {:error, reason()}

connection_trace_id(conn)

@spec connection_trace_id(connection()) :: {:ok, String.t()} | {:error, reason()}

connection_writable_streams(conn)

@spec connection_writable_streams(connection()) ::
  {:ok, [stream_id()]} | {:error, reason()}

h3_config_enable_extended_connect(config, enabled)

@spec h3_config_enable_extended_connect(h3_config(), boolean()) ::
  :ok | {:error, reason()}

h3_config_new()

@spec h3_config_new() :: {:ok, h3_config()} | {:error, reason()}

h3_config_set_additional_settings(config, settings)

@spec h3_config_set_additional_settings(h3_config(), [
  {non_neg_integer(), non_neg_integer()}
]) ::
  :ok | {:error, reason()}

h3_config_set_max_field_section_size(config, value)

@spec h3_config_set_max_field_section_size(h3_config(), non_neg_integer()) ::
  :ok | {:error, reason()}

h3_config_set_qpack_blocked_streams(config, value)

@spec h3_config_set_qpack_blocked_streams(h3_config(), non_neg_integer()) ::
  :ok | {:error, reason()}

h3_config_set_qpack_max_table_capacity(config, value)

@spec h3_config_set_qpack_max_table_capacity(h3_config(), non_neg_integer()) ::
  :ok | {:error, reason()}

h3_conn_new_with_transport(conn, h3_config)

@spec h3_conn_new_with_transport(connection(), h3_config()) ::
  {:ok, h3_connection()} | {:error, reason()}

h3_conn_poll(conn, h3_conn)

@spec h3_conn_poll(connection(), h3_connection()) ::
  {:ok, {stream_id(), term()}} | {:error, reason()}

h3_dgram_enabled_by_peer(conn, h3_conn)

@spec h3_dgram_enabled_by_peer(connection(), h3_connection()) ::
  {:ok, boolean()} | {:error, reason()}

h3_extended_connect_enabled_by_peer(h3_conn)

@spec h3_extended_connect_enabled_by_peer(h3_connection()) ::
  {:ok, boolean()} | {:error, reason()}

h3_recv_body(conn, h3_conn, stream_id, max_bytes)

@spec h3_recv_body(connection(), h3_connection(), stream_id(), non_neg_integer()) ::
  {:ok, quic_binary()} | {:error, reason()}

h3_send_body(conn, h3_conn, stream_id, body, fin)

@spec h3_send_body(
  connection(),
  h3_connection(),
  stream_id(),
  quic_binary(),
  boolean()
) ::
  :ok | {:error, reason()}

h3_send_goaway(conn, h3_conn, stream_id)

@spec h3_send_goaway(connection(), h3_connection(), stream_id()) ::
  :ok | {:error, reason()}

h3_send_request(conn, h3_conn, headers, fin)

@spec h3_send_request(
  connection(),
  h3_connection(),
  [{quic_binary(), quic_binary()}],
  boolean()
) ::
  {:ok, stream_id()} | {:error, reason()}

h3_send_response(conn, h3_conn, stream_id, headers, fin)

@spec h3_send_response(
  connection(),
  h3_connection(),
  stream_id(),
  [{quic_binary(), quic_binary()}],
  boolean()
) :: :ok | {:error, reason()}

header_info(packet, dcid_len)

@spec header_info(quic_binary(), non_neg_integer()) ::
  {:ok, Quichex.Native.PacketHeader.t()} | {:error, reason()}

retry(scid, dcid, new_scid, token, version)

@spec retry(
  quic_binary(),
  quic_binary(),
  quic_binary(),
  quic_binary(),
  non_neg_integer()
) ::
  {:ok, quic_binary()} | {:error, reason()}

version_negotiate(scid, dcid)

@spec version_negotiate(quic_binary(), quic_binary()) ::
  {:ok, quic_binary()} | {:error, reason()}