quicer_nif (quicer v0.4.3)

View Source

Summary

Types

abi_version/0
acceptor_opts/0
active_n/0
alpn/0
app_errno/0
atom_reason/0
close_registration/0
conf_handle/0
conn_opts/0
conn_shutdown_flag/0
connection_handle/0
csend_flags/0
execution_profile/0
get_connections/0
get_listeners/0
get_owner/0
get_registration_name/0
get_registration_refcnt/0
global_handle/0
handle/0
hostname/0
listen_on/0
listen_opts/0
listener_handle/0
new_registration/0
optlevel/0
optname/0
optname_configuration/0
optname_conn/0
optname_global/0
optname_listener/0
optname_reg/0
optname_stream/0
optname_tls/0
reg_handle/0
registration_profile/0
send_flags/0
shutdown_registration/0
stream_handle/0
stream_open_flags/0
stream_opts/0
stream_shutdown_flags/0
stream_start_flags/0
uint8/0
uint16/0
uint32/0
uint62/0
uint64/0

Functions

abi_version()
async_accept(Listener, Opts)
async_accept_stream(Conn, Opts)
async_connect(Host, Port, Opts)
async_handshake(Connection)
async_handshake(Connection, ConnOpts)
async_shutdown_connection(Conn, Flags, ErrorCode)
async_shutdown_stream(Stream, Flags, ErrorCode)
close_lib()
close_listener(Listener)

close the listener return closed if the listener is closed. return ok if the listener is stopped then closed, and caller should expect listener_stopped signal.

close_registration(Handle)
complete_cert_validation(Conn, IsAccepted, TlsAlert)
controlling_process(H, P)
copy_stream_handle(H)
count_reg_conns()
count_reg_conns(RegHandle)
csend(Conn, Data, Opts, Flags)
enable_sig_buffer(H)

enable signal buffering, used in stream handoff. * not exposed API.

flush_stream_buffered_sigs(H)

flush buffered stream signals to the current owner * not exposed API. also @see quicer:controlling_process/2

get_conn_owner(_)
get_conn_rid(Handle)
get_connections()
get_connections(RegHandle)
get_listener_owner(_)
get_listeners()
get_listeners(_)
get_registration_name(Handle)
get_registration_refcnt(Handle)
get_snab_kc_pid()
get_stream_owner(_)
get_stream_rid(Handle)
getopt(Handle, Optname, Level)
init(ABIVsn)
is_kill_switch_enabled()
kill_switch_name()
listen(ListenOn, Options)
malloc_stats()
malloc_trim()
mock_buffer_sig(StreamHandle, OrigOwner, Msg)

mock buffer a signal in sig_buffer. for testing sig_buffer

new_registration(Name, Profile)
open_connection()
open_connection(_)
open_lib()
peercert(Handle)
recv(Stream, Len)
reg_close()
reg_open()
reg_open(_)
send(Stream, Data, Flags)
send_dgram(Conn, Data, Flags)
set_snab_kc_pid(Pid)
setopt(Handle, Opt, Value, Level)
shutdown_registration(Handle)
shutdown_registration(Handle, IsSilent, ErrorCode)
sockname(Conn)
start_listener(Listener, ListenOn, Opts)
start_stream(Conn, Opts)
stop_listener(Listener)

Types

abi_version/0

-type abi_version() :: integer().

acceptor_opts/0

-type acceptor_opts() ::
          #{active => boolean(),
            max_bytes_per_key => uint64(),
            handshake_idle_timeout_ms => uint64(),
            idle_timeout_ms => uint64(),
            tls_client_max_send_buffer => uint32(),
            tls_server_max_send_buffer => uint32(),
            stream_recv_window_default => uint32(),
            stream_recv_buffer_default => uint32(),
            conn_flow_control_window => uint32(),
            max_stateless_operations => uint32(),
            initial_window_packets => uint32(),
            send_idle_timeout_ms => uint32(),
            initial_rtt_ms => uint32(),
            max_ack_delay_ms => uint32(),
            disconnect_timeout_ms => uint32(),
            keep_alive_interval_ms => uint32(),
            congestion_control_algorithm => uint16(),
            peer_bidi_stream_count => uint16(),
            peer_unidi_stream_count => uint16(),
            retry_memory_limit => uint16(),
            load_balancing_mode => uint16(),
            max_operations_per_drain => uint8(),
            send_buffering_enabled => uint8(),
            pacing_enabled => uint8(),
            migration_enabled => uint8(),
            datagram_receive_enabled => uint8(),
            server_resumption_level => uint8(),
            minimum_mtu => uint16(),
            maximum_mtu => uint16(),
            mtu_discovery_search_complete_timeout_us => uint64(),
            mtu_discovery_missing_probe_count => uint8(),
            max_binding_stateless_operations => uint16(),
            stateless_operation_expiration_ms => uint16()}.

active_n/0

-type active_n() :: boolean() | once | integer().

alpn/0

-type alpn() :: string().

app_errno/0

-type app_errno() :: non_neg_integer().

atom_reason/0

-type atom_reason() ::
          success | pending | continue | out_of_memory | invalid_parameter | invalid_state |
          not_supported | not_found | buffer_too_small | handshake_failure | aborted | address_in_use |
          connection_timeout | connection_idle | internal_error | connection_refused | protocol_error |
          ver_neg_error | unreachable | tls_error | user_canceled | alpn_neg_failure |
          stream_limit_reached.

close_registration/0

-type close_registration() :: ok | {error, badarg}.

conf_handle/0

-type conf_handle() :: reference().

conn_opts/0

-type conn_opts() ::
          #{alpn := [string()],
            conn_callback => module(),
            custom_verify => boolean(),
            handle => connection_handle(),
            nst => binary(),
            handshake_idle_timeout_ms => non_neg_integer(),
            quic_event_mask => uint32(),
            disable_1rtt_encryption => boolean(),
            local_address => string(),
            local_bidi_stream_count => uint16(),
            local_peer_unidi_stream_count => uint16(),
            cert => file:filename(),
            certfile => file:filename(),
            key => file:filename(),
            keyfile => file:filename(),
            password => string(),
            verify => none | peer | verify_peer | verify_none,
            cacertfile => file:filename(),
            sslkeylogfile => file:filename(),
            max_bytes_per_key => uint64(),
            handshake_idle_timeout_ms => uint64(),
            idle_timeout_ms => uint64(),
            tls_client_max_send_buffer => uint32(),
            tls_server_max_send_buffer => uint32(),
            stream_recv_window_default => uint32(),
            stream_recv_buffer_default => uint32(),
            conn_flow_control_window => uint32(),
            max_stateless_operations => uint32(),
            initial_window_packets => uint32(),
            send_idle_timeout_ms => uint32(),
            initial_rtt_ms => uint32(),
            max_ack_delay_ms => uint32(),
            disconnect_timeout_ms => uint32(),
            keep_alive_interval_ms => uint32(),
            congestion_control_algorithm => uint16(),
            peer_bidi_stream_count => uint16(),
            peer_unidi_stream_count => uint16(),
            retry_memory_limit => uint16(),
            load_balancing_mode => uint16(),
            max_operations_per_drain => uint8(),
            send_buffering_enabled => uint8(),
            pacing_enabled => uint8(),
            migration_enabled => uint8(),
            datagram_receive_enabled => uint8(),
            server_resumption_level => uint8(),
            minimum_mtu => uint16(),
            maximum_mtu => uint16(),
            mtu_discovery_search_complete_timeout_us => uint64(),
            mtu_discovery_missing_probe_count => uint8(),
            max_binding_stateless_operations => uint16(),
            stateless_operation_expiration_ms => uint16(),
            dynamic() => dynamic()}.

conn_shutdown_flag/0

-type conn_shutdown_flag() :: 0 | 1.

connection_handle/0

-type connection_handle() :: reference().

csend_flags/0

-type csend_flags() :: 0 | 1 | 2 | 4 | 8 | 16.

execution_profile/0

-type execution_profile() ::
          quic_execution_profile_low_latency | quic_execution_profile_max_throughput |
          quic_execution_profile_scavenger | quic_execution_profile_real_time.

get_connections/0

-type get_connections() :: [connection_handle()].

get_listeners/0

-type get_listeners() :: [listener_handle()].

get_owner/0

-type get_owner() :: {ok, pid()} | {error, undefined | badarg}.

get_registration_name/0

-type get_registration_name() :: {ok, string()} | {error, badarg}.

get_registration_refcnt/0

-type get_registration_refcnt() :: {error, closed} | integer().

global_handle/0

-type global_handle() :: quic_global.

handle/0

-type handle() ::
          global_handle() |
          listener_handle() |
          connection_handle() |
          stream_handle() |
          conf_handle() |
          reg_handle().

hostname/0

-type hostname() :: string().

listen_on/0

-type listen_on() :: inet:port_number() | string().

listen_opts/0

-type listen_opts() ::
          #{alpn := [alpn()],
            allow_insecure => boolean(),
            quic_registration => reg_handle(),
            conn_acceptors => non_neg_integer(),
            cert => file:filename(),
            certfile => file:filename(),
            key => file:filename(),
            keyfile => file:filename(),
            password => string(),
            verify => none | peer | verify_peer | verify_none,
            cacertfile => file:filename(),
            sslkeylogfile => file:filename(),
            max_bytes_per_key => uint64(),
            handshake_idle_timeout_ms => uint64(),
            idle_timeout_ms => uint64(),
            tls_client_max_send_buffer => uint32(),
            tls_server_max_send_buffer => uint32(),
            stream_recv_window_default => uint32(),
            stream_recv_buffer_default => uint32(),
            conn_flow_control_window => uint32(),
            max_stateless_operations => uint32(),
            initial_window_packets => uint32(),
            send_idle_timeout_ms => uint32(),
            initial_rtt_ms => uint32(),
            max_ack_delay_ms => uint32(),
            disconnect_timeout_ms => uint32(),
            keep_alive_interval_ms => uint32(),
            congestion_control_algorithm => uint16(),
            peer_bidi_stream_count => uint16(),
            peer_unidi_stream_count => uint16(),
            retry_memory_limit => uint16(),
            load_balancing_mode => uint16(),
            max_operations_per_drain => uint8(),
            send_buffering_enabled => uint8(),
            pacing_enabled => uint8(),
            migration_enabled => uint8(),
            datagram_receive_enabled => uint8(),
            server_resumption_level => uint8(),
            minimum_mtu => uint16(),
            maximum_mtu => uint16(),
            mtu_discovery_search_complete_timeout_us => uint64(),
            mtu_discovery_missing_probe_count => uint8(),
            max_binding_stateless_operations => uint16(),
            stateless_operation_expiration_ms => uint16()}.

listener_handle/0

-type listener_handle() :: reference().

new_registration/0

-type new_registration() :: {ok, reg_handle()} | {error, atom_reason()}.

optlevel/0

-type optlevel() :: false | quic_global | quic_registration | quic_configuration | quic_tls.

optname/0

-type optname() ::
          optname_global() |
          optname_listener() |
          optname_conn() |
          optname_stream() |
          optname_reg() |
          optname_configuration() |
          optname_tls().

optname_configuration/0

-type optname_configuration() :: settings | ticket_keys.

optname_conn/0

-type optname_conn() ::
          quic_version | local_address | remote_address | ideal_processor | settings | statistics |
          statistics_plat | share_udp_binding | local_bidi_stream_count | local_unidi_stream_count |
          max_stream_ids | close_reason_phrase | stream_scheduling_scheme | datagram_receive_enabled |
          datagram_send_enabled | disable_1rtt_encryption | resumption_ticket | peer_certificate_valid |
          local_interface.

optname_global/0

-type optname_global() ::
          retry_memory_percent | supported_versions | load_balacing_mode | perf_counters |
          global_settings | global_version.

optname_listener/0

-type optname_listener() :: local_address | stats | cibir_id.

optname_reg/0

-type optname_reg() :: cid_prefix.

optname_stream/0

-type optname_stream() ::
          active | controlling_process | stream_id | '0rtt_length' | ideal_send_buffer_size | priority.

optname_tls/0

-type optname_tls() :: schannel_context_attribute_w | handshake_info | negotiated_alpn.

reg_handle/0

-type reg_handle() :: reference().

registration_profile/0

-type registration_profile() :: execution_profile().

send_flags/0

-type send_flags() :: csend_flags() | 4096.

shutdown_registration/0

-type shutdown_registration() :: ok | {error, badarg | invalid_state}.

stream_handle/0

-type stream_handle() :: reference().

stream_open_flags/0

-type stream_open_flags() :: 0 | 1 | 2.

stream_opts/0

-type stream_opts() ::
          #{active := active_n(),
            open_flag => stream_open_flags(),
            start_flag => stream_start_flags(),
            event_mask => uint32(),
            disable_fpbuffer => boolean(),
            stream_id => uint62(),
            priority => uint16(),
            ideal_send_buffer_size => uint64(),
            '0rtt_length' => uint64(),
            dynamic() => dynamic()}.

stream_shutdown_flags/0

-type stream_shutdown_flags() :: 0 | 1 | 2 | 4 | 6 | 8.

stream_start_flags/0

-type stream_start_flags() :: 0 | 1 | 2 | 4 | 8.

uint8/0

-type uint8() :: 0..1 bsl 8 - 1.

uint16/0

-type uint16() :: 0..1 bsl 16 - 1.

uint32/0

-type uint32() :: 0..1 bsl 32 - 1.

uint62/0

-type uint62() :: 0..1 bsl 62 - 1.

uint64/0

-type uint64() :: 0..1 bsl 64 - 1.

Functions

abi_version()

-spec abi_version() -> abi_version().

async_accept(Listener, Opts)

-spec async_accept(listener_handle(), acceptor_opts()) ->
                      {ok, listener_handle()} | {error, badarg | param_error | not_enough_mem | badpid}.

async_accept_stream(Conn, Opts)

-spec async_accept_stream(connection_handle(), stream_opts()) ->
                             {ok, connection_handle()} |
                             {error, badarg | internal_error | bad_pid | owner_dead}.

async_connect(Host, Port, Opts)

-spec async_connect(hostname(), inet:port_number(), conn_opts()) ->
                       {ok, connection_handle()} |
                       {error, conn_open_error | config_error | conn_start_error} |
                       {error, not_found, any()}.

async_handshake(Connection)

-spec async_handshake(connection_handle()) -> ok | {error, badarg | atom_reason()}.

async_handshake(Connection, ConnOpts)

-spec async_handshake(connection_handle(), conn_opts()) -> ok | {error, badarg | atom_reason()}.

async_shutdown_connection(Conn, Flags, ErrorCode)

-spec async_shutdown_connection(connection_handle(), conn_shutdown_flag(), app_errno()) ->
                                   ok | {error, badarg}.

async_shutdown_stream(Stream, Flags, ErrorCode)

-spec async_shutdown_stream(stream_handle(), stream_shutdown_flags(), app_errno()) ->
                               ok | {error, badarg | atom_reason()}.

close_lib()

-spec close_lib() -> ok.

close_listener(Listener)

-spec close_listener(listener_handle()) -> ok | closed | {error, closed | badarg}.

close the listener return closed if the listener is closed. return ok if the listener is stopped then closed, and caller should expect listener_stopped signal.

close_registration(Handle)

-spec close_registration(reg_handle()) -> close_registration().

complete_cert_validation(Conn, IsAccepted, TlsAlert)

-spec complete_cert_validation(connection_handle(), boolean(), integer()) -> ok | {error, any()}.

controlling_process(H, P)

-spec controlling_process(connection_handle() | stream_handle(), pid()) ->
                             ok | {error, closed | badarg | owner_dead | not_owner}.

copy_stream_handle(H)

-spec copy_stream_handle(stream_handle()) -> {ok, stream_handle()} | {error, badarg}.

count_reg_conns()

-spec count_reg_conns() -> non_neg_integer().

count_reg_conns(RegHandle)

-spec count_reg_conns(reg_handle()) -> non_neg_integer() | {error, badarg}.

csend(Conn, Data, Opts, Flags)

-spec csend(connection_handle(), iodata(), stream_opts(), send_flags()) ->
               {ok, BytesSent :: pos_integer()} |
               {error, badarg | not_enough_mem | closed} |
               {error, stream_send_error, atom_reason()}.

enable_sig_buffer(H)

-spec enable_sig_buffer(stream_handle()) -> ok.

enable signal buffering, used in stream handoff. * not exposed API.

flush_stream_buffered_sigs(H)

-spec flush_stream_buffered_sigs(stream_handle()) -> ok | {error, badarg | none}.

flush buffered stream signals to the current owner * not exposed API. also @see quicer:controlling_process/2

get_conn_owner(_)

-spec get_conn_owner(connection_handle()) -> get_owner().

get_conn_rid(Handle)

-spec get_conn_rid(connection_handle()) -> {ok, non_neg_integer()} | {error, badarg | internal_error}.

get_connections()

-spec get_connections() -> [connection_handle()].

get_connections(RegHandle)

-spec get_connections(reg_handle()) -> [connection_handle()] | {error, badarg}.

get_listener_owner(_)

-spec get_listener_owner(listener_handle()) -> get_owner().

get_listeners()

-spec get_listeners() -> get_listeners().

get_listeners(_)

-spec get_listeners(reg_handle()) -> get_listeners().

get_registration_name(Handle)

-spec get_registration_name(reg_handle()) -> get_registration_name().

get_registration_refcnt(Handle)

-spec get_registration_refcnt(reg_handle()) -> get_registration_refcnt().

get_snab_kc_pid()

-spec get_snab_kc_pid() -> pid().

get_stream_owner(_)

-spec get_stream_owner(connection_handle()) -> get_owner().

get_stream_rid(Handle)

-spec get_stream_rid(stream_handle()) -> {ok, non_neg_integer()} | {error, badarg | internal_error}.

getopt(Handle, Optname, Level)

-spec getopt(handle(), optname(), optlevel()) ->
                not_found |
                {ok, any()} |
                {error, badarg | param_error | internal_error | not_enough_mem} |
                {error, atom_reason()}.

init(ABIVsn)

is_kill_switch_enabled()

-spec is_kill_switch_enabled() -> boolean().

kill_switch_name()

-spec kill_switch_name() -> string().

listen(ListenOn, Options)

-spec listen(listen_on(), listen_opts()) ->
                {ok, listener_handle()} |
                {error, listener_open_error, atom_reason()} |
                {error, listener_start_error, atom_reason()}.

malloc_stats()

-spec malloc_stats() -> ok.

malloc_trim()

-spec malloc_trim() -> ok.

mock_buffer_sig(StreamHandle, OrigOwner, Msg)

-spec mock_buffer_sig(stream_handle(), OrigOwner :: pid(), term()) ->
                         ok | {error, false | none | bad_pid | bad_arg}.

mock buffer a signal in sig_buffer. for testing sig_buffer

new_registration(Name, Profile)

-spec new_registration(Name :: string(), Profile :: registration_profile()) -> new_registration().

open_connection()

-spec open_connection() -> {ok, connection_handle()} | {error, atom_reason()}.

open_connection(_)

-spec open_connection(#{quic_registration => reg_handle()}) ->
                         {ok, connection_handle()} | {error, atom_reason()}.

open_lib()

-spec open_lib() ->
                  {ok, true} |
                  {ok, false} |
                  {ok, debug} |
                  {ok, fake} |
                  {error, open_failed, atom_reason()}.

peercert(Handle)

-spec peercert(connection_handle() | stream_handle()) ->
                  {ok, CertDerEncoded :: binary()} | {error, any()}.

recv(Stream, Len)

-spec recv(stream_handle(), non_neg_integer()) ->
              {ok, binary()} | {ok, not_ready} | {error, badarg | einval | closed}.

reg_close()

-spec reg_close() -> ok.

reg_open()

-spec reg_open() -> ok | {error, badarg | invalid_state}.

reg_open(_)

-spec reg_open(execution_profile()) -> ok | {error, badarg | invalid_state}.

send(Stream, Data, Flags)

-spec send(stream_handle(), iodata(), send_flags()) ->
              {ok, BytesSent :: pos_integer()} |
              {error, badarg | not_enough_mem | closed} |
              {error, stream_send_error, atom_reason()}.

send_dgram(Conn, Data, Flags)

-spec send_dgram(connection_handle(), iodata(), send_flags()) ->
                    {ok, BytesSent :: pos_integer()} |
                    {error, badarg | not_enough_memory | invalid_parameter | closed} |
                    {error, dgram_send_error, atom_reason()}.

set_snab_kc_pid(Pid)

-spec set_snab_kc_pid(pid()) -> ok | {error, badarg}.

setopt(Handle, Opt, Value, Level)

-spec setopt(handle(), optname(), any(), optlevel()) ->
                ok |
                {error, badarg | param_error | internal_error | not_enough_mem} |
                {error, atom_reason()}.

shutdown_registration(Handle)

-spec shutdown_registration(global | reg_handle()) -> shutdown_registration().

shutdown_registration(Handle, IsSilent, ErrorCode)

-spec shutdown_registration(global | reg_handle(), IsSilent :: boolean(), ErrorCode :: uint64()) ->
                               shutdown_registration().

sockname(Conn)

-spec sockname(connection_handle() | stream_handle()) ->
                  {ok, {inet:ip_address(), inet:port_number()}} | {error, badarg | sockname_error}.

start_listener(Listener, ListenOn, Opts)

-spec start_listener(listener_handle(), listen_on(), listen_opts()) -> ok | {error, closed | badarg}.

start_stream(Conn, Opts)

-spec start_stream(connection_handle(), stream_opts()) ->
                      {ok, stream_handle()} |
                      {error, badarg | internal_error | bad_pid | owner_dead | not_enough_mem} |
                      {error, stream_open_error, atom_reason()} |
                      {error, stream_start_error, atom_reason()}.

stop_listener(Listener)

-spec stop_listener(listener_handle()) -> ok | {error, closed | listener_stopped | badarg}.