Struct moq_client_config 

#[repr(C)]
pub struct moq_client_config {

    pub versions: *const moq_string,
    pub versions_len: usize,
    pub bind: *const c_char,
    pub bind_len: usize,
    pub connect_timeout_us: u64,
    pub has_connect_timeout: bool,
    pub failover_delay_us: u64,
    pub has_failover_delay: bool,
    pub resolution_delay_us: u64,
    pub has_resolution_delay: bool,
    pub websocket_enabled: bool,
    pub has_websocket_enabled: bool,
    pub websocket_delay_us: u64,
    pub has_websocket_delay: bool,
    pub tls_disable_verify: bool,
    pub tls_system_roots: bool,
    pub has_tls_system_roots: bool,
    pub tls_roots: *const moq_string,
    pub tls_roots_len: usize,
    pub tls_fingerprints: *const moq_string,
    pub tls_fingerprints_len: usize,
    pub tls_host_name: *const c_char,
    pub tls_host_name_len: usize,
    pub tls_cert: *const c_char,
    pub tls_cert_len: usize,
    pub tls_key: *const c_char,
    pub tls_key_len: usize,
    pub backoff_initial_us: u64,
    pub has_backoff_initial: bool,
    pub backoff_multiplier: u32,
    pub has_backoff_multiplier: bool,
    pub backoff_max_us: u64,
    pub has_backoff_max: bool,
    pub backoff_timeout_us: u64,
    pub has_backoff_timeout: bool,
    pub quic_max_streams: u64,
    pub has_quic_max_streams: bool,
    pub quic_idle_timeout_us: u64,
    pub has_quic_idle_timeout: bool,
    pub quic_keep_alive_us: u64,
    pub has_quic_keep_alive: bool,
    pub quic_gso: bool,
    pub has_quic_gso: bool,
    pub quic_mtu_discovery: bool,
    pub has_quic_mtu_discovery: bool,
    pub quic_congestion_control: *const c_char,
    pub quic_congestion_control_len: usize,
    pub quic_qlog: *const c_char,
    pub quic_qlog_len: usize,
}

Settings for moq_session_connect, or NULL to dial with the defaults.

Zero it (memset, or a {0} initializer) and set only what you need: a zeroed struct means the defaults throughout. That is why the knobs whose default is not zero carry a has_* flag rather than being read directly. The WebSocket fallback is on by default and the reconnect backoff starts at one second, so a caller who never touched them would otherwise silently turn them off.

New settings are appended to the end of this struct, and a zeroed one keeps the previous behavior, so adding one does not disturb existing callers.

Fields

versions: *const moq_string

Protocol versions to offer during the handshake, most preferred first. NULL/0 offers everything this build supports. Names are spelled the way the CLI spells them (moq-lite-05, moq-transport-22); moq_versions lists what is on offer.

versions_len: usize

bind: *const c_char

Local socket address to bind, or NULL for the wildcard address.

bind_len: usize

connect_timeout_us: u64

How long a dial may take before it gives up.

has_connect_timeout: bool

failover_delay_us: u64

Happy Eyeballs: how long before the next address is also dialed.

has_failover_delay: bool

resolution_delay_us: u64

Happy Eyeballs: how long the first family waits for the AAAA answer.

has_resolution_delay: bool

websocket_enabled: bool

Whether the WebSocket fallback may be raced, for a UDP-blocked network. Enabled unless you turn it off, hence the flag.

has_websocket_enabled: bool

websocket_delay_us: u64

How long QUIC gets before the WebSocket fallback is also dialed.

has_websocket_delay: bool

tls_disable_verify: bool

Accept any certificate. Development only: prefer tls_fingerprints, and pairing this with a fingerprint or a root is rejected at dial.

tls_system_roots: bool

Whether to trust the platform root store. Its default depends on the backend, so it needs the flag to distinguish “off” from “unset”.

has_tls_system_roots: bool

tls_roots: *const moq_string

Extra root certificate paths to trust.

tls_roots_len: usize

tls_fingerprints: *const moq_string

SHA-256 certificate fingerprints to pin, hex encoded. The native equivalent of the browser’s serverCertificateHashes.

tls_fingerprints_len: usize

tls_host_name: *const c_char

SNI override, or NULL to use the host from the URL.

tls_host_name_len: usize

tls_cert: *const c_char

Client certificate and key paths for mTLS, or NULL for none.

tls_cert_len: usize

tls_key: *const c_char

tls_key_len: usize

backoff_initial_us: u64

Reconnect pacing. Each must leave a non-zero delay or retrying would spin, which is rejected at dial.

has_backoff_initial: bool

backoff_multiplier: u32

has_backoff_multiplier: bool

backoff_max_us: u64

has_backoff_max: bool

backoff_timeout_us: u64

How long reconnection keeps trying before giving up for good.

has_backoff_timeout: bool

quic_max_streams: u64

QUIC transport tuning, all ignored by the WebSocket fallback.

has_quic_max_streams: bool

quic_idle_timeout_us: u64

has_quic_idle_timeout: bool

quic_keep_alive_us: u64

has_quic_keep_alive: bool

quic_gso: bool

Generic segmentation offload and path MTU discovery. Both default to the backend’s choice, so both need their flag.

has_quic_gso: bool

quic_mtu_discovery: bool

has_quic_mtu_discovery: bool

quic_congestion_control: *const c_char

Congestion control family name, or NULL for the backend’s choice.

quic_congestion_control_len: usize

quic_qlog: *const c_char

Directory to write qlog traces into, or NULL for none. Capture is compile-time optional; see moq_qlog_supported.

quic_qlog_len: usize