client.h File Reference

Go to the source code of this file.

Typedefs
typedef struct crypto_context_t	crypto_context_t

Functions
int	client_init (void)
int	client_opus_encoder_init (int sample_rate, int channels, int bitrate)
int	client_opus_decoder_init (int sample_rate, int channels)
int	client_opus_encode (const int16_t *pcm_data, int frame_size, uint8_t *opus_data, int max_opus_bytes)
int	client_opus_decode (const uint8_t *opus_data, int opus_bytes, int16_t *pcm_data, int frame_size, int decode_fec)
void	client_opus_encoder_cleanup (void)
void	client_opus_decoder_cleanup (void)
int	client_set_server_address (const char *server_host, int server_port)
const uint8_t *	client_public_key_bytes (void)
int	client_handle_crypto_parameters (const uint8_t *packet, size_t packet_len)
int	client_handle_key_exchange_init (const uint8_t *packet, size_t packet_len)
int	client_handle_auth_challenge (const uint8_t *packet, size_t packet_len)
int	client_handle_handshake_complete (const uint8_t *packet, size_t packet_len)
asciichat_error_t	client_handshake_receive (uint32_t type, const void *payload, size_t length)
asciichat_error_t	client_acds_handshake_receive (uint32_t type, const void *payload, size_t length)
int	client_encrypt_packet (const uint8_t *plaintext, size_t plaintext_len, uint8_t *ciphertext, size_t ciphertext_size, size_t *out_len)
int	client_decrypt_packet (const uint8_t *ciphertext, size_t ciphertext_len, uint8_t *plaintext, size_t plaintext_size, size_t *out_len)
asciichat_error_t	client_settings_receive (const void *payload, size_t length)
char *	client_settings_values (void)
asciichat_error_t	client_validate_frame (const char *text, size_t length, uint32_t width, uint32_t height, uint32_t checksum, uint32_t flags, const void *metadata, size_t metadata_length)
asciichat_error_t	client_decode_frame_data (const void *encoded, size_t encoded_length, void *output, size_t output_length)
int	client_parse_ssh_private_key (const char *key_path, uint8_t *secret_key_out)
int	client_parse_ssh_public_key (const char *key_line, uint8_t *public_key_out)
int	client_parse_gpg_private_key (const char *armored_key, uint8_t *secret_key_out)
int	client_parse_gpg_public_key (const char *armored_key, uint8_t *public_key_out)
int	client_parse_gpg_private_key_binary (const uint8_t *key_data, size_t key_data_len, uint8_t *secret_key_out)
int	client_parse_gpg_public_key_binary (const uint8_t *key_data, size_t key_data_len, uint8_t *public_key_out)
int	client_get_crypto_error_message (char *output, size_t output_size)
crypto_context_t *	client_security_context (void)
int	client_configure_crypto_options (const char *password, const uint8_t *identity_secret_key, const uint8_t *expected_server_public_key)
void	client_cleanup (void)
int	client_generate_keypair (void)
int	client_get_connection_state (void)
int	client_resolve_crypto_policy (bool secure, int encryption)
asciichat_error_t	client_handshake_begin (void)
asciichat_error_t	client_acds_handshake_begin (uint8_t mode)

Typedef Documentation

crypto_context_t

typedef struct crypto_context_t crypto_context_t

Browser-facing C interface implemented in client.c.

Definition at line 9 of file src/web/client.h.

Function Documentation

client_acds_handshake_begin()

asciichat_error_t client_acds_handshake_begin

(

uint8_t

mode

)

Definition at line 988 of file src/web/client.c.

                                                            {
  g_crypto_handshake_ctx.crypto_ctx.encrypt_data = ACIP_CRYPTO_HAS_ENCRYPT(mode);
  return acds_handshake_begin(&g_wasm_transport, mode);
}

References acds_handshake_begin(), and ACIP_CRYPTO_HAS_ENCRYPT.

Referenced by EMSCRIPTEN_BINDINGS().

client_acds_handshake_receive()

asciichat_error_t client_acds_handshake_receive	(	uint32_t	type,
		const void *	payload,
		size_t	length )

Definition at line 992 of file src/web/client.c.

                                                                                                   {
  asciichat_error_t result = acds_handshake_receive(&g_crypto_handshake_ctx, &g_wasm_transport, type, payload, length);
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return result;
  }
  if (g_crypto_handshake_ctx.state == CRYPTO_HANDSHAKE_READY) {
    g_handshake_complete = true;
    g_wasm_transport.crypto_ctx = &g_crypto_handshake_ctx.crypto_ctx;
    g_connection_state = CONNECTION_STATE_CONNECTED;
  } else {
    g_connection_state = CONNECTION_STATE_HANDSHAKE;
  }
  return ASCIICHAT_OK;
}

References acds_handshake_receive(), ASCIICHAT_OK, CONNECTION_STATE_CONNECTED, CONNECTION_STATE_ERROR, CONNECTION_STATE_HANDSHAKE, and CRYPTO_HANDSHAKE_READY.

Referenced by client_handshake_receive().

client_cleanup()

void client_cleanup

(

void

)

Definition at line 432 of file src/web/client.c.

                          {
  remote_render_settings = (acip_render_settings_t){0};
  errno_destroy();
 
  // Clean up crypto handshake context
  crypto_handshake_destroy(&g_crypto_handshake_ctx);
  memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
 
  g_handshake_complete = false;
  g_wasm_transport.crypto_ctx = NULL;
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
  sodium_memzero(g_crypto_password, sizeof(g_crypto_password));
  sodium_memzero(g_client_identity_key, sizeof(g_client_identity_key));
  sodium_memzero(g_expected_server_identity_key, sizeof(g_expected_server_identity_key));
  g_has_client_identity_key = false;
  g_has_expected_server_identity_key = false;
  // Keep module-wide options and buffer domains alive while browser renderers
  // still reference them. Connection cleanup only resets authentication state.
}

References CONNECTION_STATE_DISCONNECTED, crypto_handshake_destroy(), and errno_destroy().

Referenced by EMSCRIPTEN_BINDINGS(), and ClientSessionBinding::~ClientSessionBinding().

client_configure_crypto_options()

int client_configure_crypto_options	(	const char *	password,
		const uint8_t *	identity_secret_key,
		const uint8_t *	expected_server_public_key )

Configure browser-provided authentication material for the next handshake.

Definition at line 221 of file src/web/client.c.

                                                                               {
  if (!g_initialized) {
    SET_ERRNO(ERROR_INVALID_STATE, "Client is not initialized");
    return -1;
  }
 
  sodium_memzero(g_crypto_password, sizeof(g_crypto_password));
  sodium_memzero(g_client_identity_key, sizeof(g_client_identity_key));
  sodium_memzero(g_expected_server_identity_key, sizeof(g_expected_server_identity_key));
  g_has_client_identity_key = false;
  g_has_expected_server_identity_key = false;
 
  if (password && password[0] != '\0') {
    size_t length = strnlen(password, sizeof(g_crypto_password));
    if (length < 8 || length >= sizeof(g_crypto_password)) {
      SET_ERRNO(ERROR_INVALID_PARAM, "Client password must contain 8 to %zu bytes", sizeof(g_crypto_password) - 1);
      return -1;
    }
    SAFE_STRNCPY(g_crypto_password, password, sizeof(g_crypto_password) - 1);
  }
 
  if (identity_secret_key) {
    uint8_t derived_public_key[crypto_sign_PUBLICKEYBYTES];
    if (crypto_sign_ed25519_sk_to_pk(derived_public_key, identity_secret_key) != 0 ||
        sodium_memcmp(derived_public_key, identity_secret_key + crypto_sign_SEEDBYTES, crypto_sign_PUBLICKEYBYTES) !=
            0) {
      sodium_memzero(derived_public_key, sizeof(derived_public_key));
      SET_ERRNO(ERROR_INVALID_PARAM, "Client identity secret key is invalid");
      return -1;
    }
    memcpy(g_client_identity_key, identity_secret_key, sizeof(g_client_identity_key));
    sodium_memzero(derived_public_key, sizeof(derived_public_key));
    g_has_client_identity_key = true;
  }
 
  if (expected_server_public_key) {
    memcpy(g_expected_server_identity_key, expected_server_public_key, sizeof(g_expected_server_identity_key));
    g_has_expected_server_identity_key = true;
  }
  return 0;
}

References ERROR_INVALID_PARAM, ERROR_INVALID_STATE, SAFE_STRNCPY, and SET_ERRNO.

client_decode_frame_data()

asciichat_error_t client_decode_frame_data	(	const void *	encoded,
		size_t	encoded_length,
		void *	output,
		size_t	output_length )

Definition at line 1102 of file src/web/client.c.

                                                                 {
  if (!encoded || !output || !encoded_length || encoded_length > FRAME_RENDER_MAX_BYTES || !output_length ||
      output_length > FRAME_RENDER_MAX_BYTES)
    return SET_ERRNO(ERROR_INVALID_FRAME, "Invalid browser frame decompression bounds");
  return decompress_data_exact(encoded, encoded_length, output, output_length);
}

References decompress_data_exact(), ERROR_INVALID_FRAME, FRAME_RENDER_MAX_BYTES, and SET_ERRNO.

client_decrypt_packet()

int client_decrypt_packet	(	const uint8_t *	ciphertext,
		size_t	ciphertext_len,
		uint8_t *	plaintext,
		size_t	plaintext_size,
		size_t *	out_len )

Decrypt a ciphertext packet

Parameters

ciphertext	Input ciphertext data
ciphertext_len	Length of ciphertext
plaintext	Output buffer (allocated by caller, must be at least ciphertext_len)
plaintext_size	Size of plaintext buffer
out_len	Output parameter for plaintext length

Returns

0 on success, -1 on error

Definition at line 814 of file src/web/client.c.

                                           {
  if (!g_handshake_complete) {
    SET_ERRNO(ERROR_INVALID_STATE, "Client handshake is not complete");
    return -1;
  }
 
  if (!ciphertext || !plaintext || !out_len || plaintext_size < ciphertext_len) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client decryption buffers or lengths");
    return -1;
  }
  *out_len = 0;
  uint8_t *plain = NULL;
  size_t length = 0;
  uint64_t sequence;
  bool consumed = false;
  asciichat_error_t result =
      acip_security_decrypt(&g_crypto_handshake_ctx.crypto_ctx, CRYPTO_RECORD_ANY_CHANNEL, ACIP_DELIVERY_RELIABLE,
                            ciphertext, ciphertext_len, &plain, &length, &sequence, &consumed);
  if (result == ASCIICHAT_OK && !consumed) {
    memcpy(plaintext, plain, length);
    *out_len = length;
  }
  buffer_release(plain);
  return result == ASCIICHAT_OK ? 0 : -1;
}

References ACIP_DELIVERY_RELIABLE, acip_security_decrypt(), ASCIICHAT_OK, buffer_release, CRYPTO_RECORD_ANY_CHANNEL, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, and SET_ERRNO.

client_encrypt_packet()

int client_encrypt_packet	(	const uint8_t *	plaintext,
		size_t	plaintext_len,
		uint8_t *	ciphertext,
		size_t	ciphertext_size,
		size_t *	out_len )

Encrypt a plaintext packet

Parameters

plaintext	Input plaintext data
plaintext_len	Length of plaintext
ciphertext	Output buffer (allocated by caller, must be at least plaintext_len + crypto_aead_overhead)
ciphertext_size	Size of ciphertext buffer
out_len	Output parameter for ciphertext length

Returns

0 on success, -1 on error

Definition at line 773 of file src/web/client.c.

                                           {
  if (!g_handshake_complete) {
    SET_ERRNO(ERROR_INVALID_STATE, "Client handshake is not complete");
    return -1;
  }
 
  const size_t overhead = 32 + CRYPTO_NONCE_SIZE + CRYPTO_MAC_SIZE;
  if (!plaintext || !ciphertext || !out_len || plaintext_len > SIZE_MAX - overhead ||
      ciphertext_size < plaintext_len + overhead) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client encryption buffers or lengths");
    return -1;
  }
  uint8_t *wire = NULL;
  size_t length = 0;
  packet_header_t header;
  if (plaintext_len < sizeof(header)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Client plaintext packet is shorter than its header");
    return -1;
  }
  memcpy(&header, plaintext, sizeof(header));
  acip_traffic_class_t channel = acip_packet_traffic_class(NET_TO_HOST_U16(header.type));
  asciichat_error_t result = acip_security_seal(&g_crypto_handshake_ctx.crypto_ctx, channel, ACIP_DELIVERY_RELIABLE,
                                                plaintext, plaintext_len, &wire, &length);
  if (result == ASCIICHAT_OK) {
    *out_len = length - sizeof(packet_header_t);
    memcpy(ciphertext, wire + sizeof(packet_header_t), *out_len);
  }
  buffer_release(wire);
  return result == ASCIICHAT_OK ? 0 : -1;
}

References ACIP_DELIVERY_RELIABLE, acip_packet_traffic_class(), acip_security_seal(), ASCIICHAT_OK, buffer_release, CRYPTO_MAC_SIZE, CRYPTO_NONCE_SIZE, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, NET_TO_HOST_U16, and SET_ERRNO.

client_generate_keypair()

int client_generate_keypair

(

void

)

Generate client keypair for handshake

Returns

0 on success, -1 on error

Definition at line 460 of file src/web/client.c.

                                  {
 
  if (!g_initialized) {
    SET_ERRNO(ERROR_INVALID_STATE, "Client is not initialized");
    return -1;
  }
 
  // A replacement handshake must not retain the previous connection's sequence state.
  // Reset handshake context if previously used (reconnection / React Strict Mode remount)
  if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_DISABLED) {
    crypto_handshake_destroy(&g_crypto_handshake_ctx);
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
    g_handshake_complete = false;
  }
 
  // Initialize crypto handshake context
  asciichat_error_t result = crypto_handshake_init("wasm-client", &g_crypto_handshake_ctx, false /* is_server */);
  if (result != ASCIICHAT_OK) {
    return -1;
  }
  if (apply_client_crypto_options() != 0) {
    crypto_handshake_destroy(&g_crypto_handshake_ctx);
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
    return -1;
  }
 
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
  return 0;
}

References ASCIICHAT_OK, CONNECTION_STATE_DISCONNECTED, crypto_handshake_destroy(), CRYPTO_HANDSHAKE_DISABLED, crypto_handshake_init(), ERROR_INVALID_STATE, and SET_ERRNO.

Referenced by EMSCRIPTEN_BINDINGS().

client_get_connection_state()

int client_get_connection_state

(

void

)

Get current connection state

Returns

Connection state enum value

Definition at line 849 of file src/web/client.c.

                                      {
  return (int)g_connection_state;
}

Referenced by EMSCRIPTEN_BINDINGS().

client_get_crypto_error_message()

int client_get_crypto_error_message	(	char *	output,
		size_t	output_size )

Copy the most recent C crypto error into a caller-provided buffer.

Definition at line 378 of file src/web/client.c.

                                                                      {
  if (!output || output_size == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid crypto error output buffer");
    return -1;
  }
  asciichat_error_context_t context = {0};
  if (!HAS_ERRNO(&context) || !context.context_message[0])
    return -1;
  safe_snprintf(output, output_size, "%s", context.context_message);
  return 0;
}

References asciichat_error_context_t::context_message, ERROR_INVALID_PARAM, HAS_ERRNO, safe_snprintf(), and SET_ERRNO.

client_handle_auth_challenge()

int client_handle_auth_challenge	(	const uint8_t *	packet,
		size_t	packet_len )

Handle CRYPTO_AUTH_CHALLENGE packet from server

Parameters

packet	Raw packet data including header
packet_len	Total packet length

Returns

0 on success, -1 on error

Definition at line 666 of file src/web/client.c.

                                                                           {
 
  if (!packet || packet_len == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client authentication challenge packet");
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Client authentication challenge is shorter than its header");
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer domain (crypto function takes ownership and frees it)
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Process auth challenge
  asciichat_error_t result = crypto_handshake_client_auth_response(&g_crypto_handshake_ctx, &g_wasm_transport,
                                                                   packet_type, payload, payload_len);
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  return 0;
}

References ASCIICHAT_OK, buffer_alloc(), CONNECTION_STATE_ERROR, crypto_handshake_client_auth_response(), ERROR_INVALID_PARAM, and SET_ERRNO.

client_handle_crypto_parameters()

int client_handle_crypto_parameters	(	const uint8_t *	packet,
		size_t	packet_len )

Handle CRYPTO_PARAMETERS packet from server Sets up the key size negotiation before KEY_EXCHANGE_INIT

Parameters

packet	Raw packet data including header
packet_len	Total packet length

Returns

0 on success, -1 on error

Definition at line 600 of file src/web/client.c.

                                                                              {
 
  if (!packet || packet_len == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client crypto parameters packet");
    return -1;
  }
 
  // Discovery sends CRYPTO_PARAMETERS before KEY_EXCHANGE_INIT. Initialize
  // here so the negotiated values survive the subsequent key exchange packet.
  if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_INIT) {
    if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_DISABLED) {
      crypto_handshake_destroy(&g_crypto_handshake_ctx);
    }
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
    if (crypto_handshake_init("wasm-client", &g_crypto_handshake_ctx, false) != ASCIICHAT_OK) {
      return -1;
    }
    if (apply_client_crypto_options() != 0)
      return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Client crypto parameters packet is shorter than its header");
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer domain
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Process crypto parameters
  asciichat_error_t result =
      crypto_handshake_set_parameters(&g_crypto_handshake_ctx, (const crypto_parameters_packet_t *)payload);
 
  // Free payload
  if (payload) {
    buffer_release(payload);
  }
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  return 0;
}

References ASCIICHAT_OK, buffer_alloc(), buffer_release, CONNECTION_STATE_ERROR, crypto_handshake_destroy(), CRYPTO_HANDSHAKE_DISABLED, CRYPTO_HANDSHAKE_INIT, crypto_handshake_init(), crypto_handshake_set_parameters(), ERROR_INVALID_PARAM, and SET_ERRNO.

client_handle_handshake_complete()

int client_handle_handshake_complete	(	const uint8_t *	packet,
		size_t	packet_len )

Handle CRYPTO_HANDSHAKE_COMPLETE packet from server

Parameters

packet	Raw packet data including header
packet_len	Total packet length

Returns

0 on success, -1 on error

Definition at line 713 of file src/web/client.c.

                                                                               {
 
  if (!packet || packet_len == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client handshake completion packet");
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Client handshake completion is shorter than its header");
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer domain (crypto function takes ownership and frees it)
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Complete handshake (takes ownership of payload and will free it)
  asciichat_error_t result =
      crypto_handshake_client_complete(&g_crypto_handshake_ctx, &g_wasm_transport, packet_type, payload, payload_len);
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  g_handshake_complete = true;
  g_connection_state = CONNECTION_STATE_CONNECTED;
 
  // Update transport with the crypto context so ACIP can encrypt/decrypt packets
  g_wasm_transport.crypto_ctx = &g_crypto_handshake_ctx.crypto_ctx;
 
  return 0;
}

References ASCIICHAT_OK, buffer_alloc(), CONNECTION_STATE_CONNECTED, CONNECTION_STATE_ERROR, crypto_handshake_client_complete(), ERROR_INVALID_PARAM, and SET_ERRNO.

client_handle_key_exchange_init()

int client_handle_key_exchange_init	(	const uint8_t *	packet,
		size_t	packet_len )

Handle CRYPTO_KEY_EXCHANGE_INIT packet from server This is the first step of the crypto handshake

Parameters

packet	Raw packet data including header
packet_len	Total packet length

Returns

0 on success, -1 on error

Definition at line 529 of file src/web/client.c.

                                                                              {
 
  // Safety check: if handshake context is not in INIT state, reinitialize it
  // This handles cases where previous handshakes weren't properly cleaned up
  if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_INIT) {
 
    // Destroy and reset
    if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_DISABLED) {
      crypto_handshake_destroy(&g_crypto_handshake_ctx);
    }
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
 
    // Reinitialize to INIT state
    asciichat_error_t init_result = crypto_handshake_init("wasm-client", &g_crypto_handshake_ctx, false);
    if (init_result != ASCIICHAT_OK) {
      return -1;
    }
    if (apply_client_crypto_options() != 0)
      return -1;
  }
 
  if (!packet || packet_len == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client handshake packet");
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Client handshake packet is shorter than its header");
    return -1;
  }
 
  const packet_header_t *header = (const packet_header_t *)packet;
  packet_type_t packet_type = ntohs(header->type);
  const uint8_t *payload_src = packet + sizeof(packet_header_t);
  size_t payload_len = packet_len - sizeof(packet_header_t);
 
  // Allocate payload copy from buffer domain (crypto function takes ownership and frees it)
  // The raw packet pointer from JS cannot be passed directly because the crypto
  // handshake function calls buffer_release() on the payload when done.
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_alloc(NULL, payload_len);
    if (!payload) {
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Process key exchange using transport-abstracted handshake
 
  asciichat_error_t result = crypto_handshake_client_key_exchange(&g_crypto_handshake_ctx, &g_wasm_transport,
                                                                  packet_type, payload, payload_len);
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  g_connection_state = CONNECTION_STATE_HANDSHAKE;
  return 0;
}

References ASCIICHAT_OK, buffer_alloc(), CONNECTION_STATE_ERROR, CONNECTION_STATE_HANDSHAKE, crypto_handshake_client_key_exchange(), crypto_handshake_destroy(), CRYPTO_HANDSHAKE_DISABLED, CRYPTO_HANDSHAKE_INIT, crypto_handshake_init(), ERROR_INVALID_PARAM, and SET_ERRNO.

client_handshake_begin()

asciichat_error_t client_handshake_begin

(

void

)

Definition at line 1025 of file src/web/client.c.

                                               {
  g_connection_state = CONNECTION_STATE_CONNECTING;
  g_version_received = false;
  g_crypto_handshake_ctx.crypto_ctx.encrypt_data = ACIP_CRYPTO_HAS_ENCRYPT(g_crypto_mode);
  return acds_handshake_begin(&g_wasm_transport, g_crypto_mode);
}

References acds_handshake_begin(), ACIP_CRYPTO_HAS_ENCRYPT, and CONNECTION_STATE_CONNECTING.

Referenced by EMSCRIPTEN_BINDINGS().

client_handshake_receive()

asciichat_error_t client_handshake_receive	(	uint32_t	type,
		const void *	payload,
		size_t	length )

Definition at line 1032 of file src/web/client.c.

                                                                                              {
  if (!g_version_received && type != PACKET_TYPE_PROTOCOL_VERSION)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Expected server protocol version first");
  if (type == PACKET_TYPE_PROTOCOL_VERSION) {
    if (g_version_received)
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Duplicate server protocol version");
    if (!payload || length != sizeof(protocol_version_packet_t))
      return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid server protocol version");
    const protocol_version_packet_t *version = payload;
    if (NET_TO_HOST_U16(version->protocol_version) != PROTOCOL_VERSION_MAJOR ||
        version->supports_encryption != g_crypto_mode)
      return SET_ERRNO(ERROR_CRYPTO, "Server rejected requested security policy");
    g_version_received = true;
    if (g_crypto_mode == ACIP_CRYPTO_NONE) {
      g_connection_state = CONNECTION_STATE_CONNECTED;
      return ASCIICHAT_OK;
    }
    crypto_capabilities_packet_t caps = {0};
    caps.supported_kex_algorithms = HOST_TO_NET_U16(KEX_ALGO_X25519);
    caps.supported_auth_algorithms = HOST_TO_NET_U16(AUTH_ALGO_ED25519 | AUTH_ALGO_NONE);
    caps.supported_cipher_algorithms = HOST_TO_NET_U16(CIPHER_ALGO_XSALSA20_POLY1305 | CIPHER_ALGO_NONE);
    caps.preferred_kex = KEX_ALGO_X25519;
    caps.preferred_auth = ACIP_CRYPTO_HAS_AUTH(g_crypto_mode) ? AUTH_ALGO_ED25519 : AUTH_ALGO_NONE;
    caps.preferred_cipher = ACIP_CRYPTO_HAS_ENCRYPT(g_crypto_mode) ? CIPHER_ALGO_XSALSA20_POLY1305 : CIPHER_ALGO_NONE;
    caps.requires_verification = g_has_expected_server_identity_key;
    asciichat_error_t result =
        packet_send_via_transport(&g_wasm_transport, PACKET_TYPE_CRYPTO_CAPABILITIES, &caps, sizeof(caps), 0);
    if (result != ASCIICHAT_OK || !g_has_expected_server_identity_key)
      return result;
    return packet_send_via_transport(&g_wasm_transport, PACKET_TYPE_CRYPTO_CLIENT_HELLO, g_expected_server_identity_key,
                                     sizeof(g_expected_server_identity_key), 0);
  }
  if (type == PACKET_TYPE_CRYPTO_PARAMETERS) {
    if (!payload || length != sizeof(crypto_parameters_packet_t) ||
        (((const crypto_parameters_packet_t *)payload)->selected_cipher != CIPHER_ALGO_NONE) !=
            ACIP_CRYPTO_HAS_ENCRYPT(g_crypto_mode))
      return SET_ERRNO(ERROR_CRYPTO, "Server changed requested payload encryption");
  }
  return client_acds_handshake_receive(type, payload, length);
}

References ACIP_CRYPTO_HAS_AUTH, ACIP_CRYPTO_HAS_ENCRYPT, ACIP_CRYPTO_NONE, ASCIICHAT_OK, AUTH_ALGO_ED25519, AUTH_ALGO_NONE, CIPHER_ALGO_NONE, CIPHER_ALGO_XSALSA20_POLY1305, client_acds_handshake_receive(), CONNECTION_STATE_CONNECTED, ERROR_CRYPTO, ERROR_NETWORK_PROTOCOL, HOST_TO_NET_U16, KEX_ALGO_X25519, NET_TO_HOST_U16, packet_send_via_transport(), PACKET_TYPE_CRYPTO_CAPABILITIES, PACKET_TYPE_CRYPTO_CLIENT_HELLO, PACKET_TYPE_CRYPTO_PARAMETERS, PACKET_TYPE_PROTOCOL_VERSION, crypto_capabilities_packet_t::preferred_auth, crypto_capabilities_packet_t::preferred_cipher, crypto_capabilities_packet_t::preferred_kex, protocol_version_packet_t::protocol_version, PROTOCOL_VERSION_MAJOR, crypto_capabilities_packet_t::requires_verification, SET_ERRNO, crypto_capabilities_packet_t::supported_auth_algorithms, crypto_capabilities_packet_t::supported_cipher_algorithms, crypto_capabilities_packet_t::supported_kex_algorithms, and protocol_version_packet_t::supports_encryption.

client_init()

int client_init

(

void

)

Initialize client mode with native defaults.

Returns

0 on success, -1 on error

Definition at line 398 of file src/web/client.c.

                      {
  // The module, renderers, and allocator outlive individual connections.
  if (g_initialized)
    return 0;
  char *argv[] = {"client", NULL};
  asciichat_error_t err = options_init(1, argv);
  if (err != ASCIICHAT_OK)
    return -1;
 
  // Initialize platform layer
  err = platform_init();
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  // Honor the requested verbosity and let INFO use stdout (console.log).
  log_init(NULL, GET_OPTION(log_level), false, false);
  // Use debug-style format in WASM so browser console shows full log headers
  log_set_format(OPT_LOG_TEMPLATE_DEFAULT_DEBUG, false);
  log_info("WASM client initialized via logging system");
 
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  // Initialize ANSI color code generation
  ansi_fast_init();
 
  g_initialized = true;
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
 
  return 0;
}

References ansi_fast_init(), ASCIICHAT_OK, CONNECTION_STATE_DISCONNECTED, GET_OPTION, log_info, log_init(), log_set_format(), OPT_LOG_TEMPLATE_DEFAULT_DEBUG, options_init(), and platform_init().

client_opus_decode()

int client_opus_decode	(	const uint8_t *	opus_data,
		int	opus_bytes,
		int16_t *	pcm_data,
		int	frame_size,
		int	decode_fec )

Decode Opus audio to PCM

Parameters

opus_data	Input Opus data
opus_bytes	Length of Opus data
pcm_data	Output buffer for PCM samples (Int16)
frame_size	Maximum number of samples per channel
decode_fec	Whether to use FEC

Returns

Number of samples decoded per channel, or -1 on error

Definition at line 948 of file src/web/client.c.

                                                                                                                    {
  if (!g_opus_decoder) {
    SET_ERRNO(ERROR_INVALID_STATE, "Opus decoder is not initialized");
    return -1;
  }
 
  if ((!opus_data && opus_bytes > 0) || opus_bytes < 0 || !pcm_data || frame_size <= 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid Opus decoder buffers or lengths");
    return -1;
  }
 
  int decoded_samples = opus_decode(g_opus_decoder, opus_data, opus_bytes, pcm_data, frame_size, decode_fec);
  if (decoded_samples < 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Opus decoding failed: %s", opus_strerror(decoded_samples));
    return -1;
  }
 
  return decoded_samples;
}

References ERROR_INVALID_PARAM, ERROR_INVALID_STATE, and SET_ERRNO.

Referenced by OpusCodecBinding::decode().

client_opus_decoder_cleanup()

void client_opus_decoder_cleanup

(

void

)

Cleanup Opus decoder

Definition at line 981 of file src/web/client.c.

                                       {
  if (g_opus_decoder) {
    opus_decoder_destroy(g_opus_decoder);
    g_opus_decoder = NULL;
  }
}

Referenced by OpusCodecBinding::~OpusCodecBinding().

client_opus_decoder_init()

int client_opus_decoder_init	(	int	sample_rate,
		int	channels )

Initialize Opus decoder

Parameters

sample_rate	Sample rate (8000, 16000, 24000, or 48000)
channels	Number of channels (1=mono, 2=stereo)

Returns

0 on success, -1 on error

Definition at line 895 of file src/web/client.c.

                                                            {
  if (g_opus_decoder) {
    opus_decoder_destroy(g_opus_decoder);
    g_opus_decoder = NULL;
  }
 
  int error;
  g_opus_decoder = opus_decoder_create(sample_rate, channels, &error);
  if (error != OPUS_OK || !g_opus_decoder) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Cannot initialize Opus decoder: %s", opus_strerror(error));
    return -1;
  }
 
  return 0;
}

References ERROR_INVALID_PARAM, and SET_ERRNO.

Referenced by OpusCodecBinding::OpusCodecBinding().

client_opus_encode()

int client_opus_encode	(	const int16_t *	pcm_data,
		int	frame_size,
		uint8_t *	opus_data,
		int	max_opus_bytes )

Encode PCM audio to Opus

Parameters

pcm_data	Input PCM data (Int16 samples)
frame_size	Number of samples per channel
opus_data	Output buffer for Opus data
max_opus_bytes	Maximum size of output buffer

Returns

Number of bytes encoded, or -1 on error

Definition at line 919 of file src/web/client.c.

                                                                                                        {
  if (!g_opus_encoder) {
    SET_ERRNO(ERROR_INVALID_STATE, "Opus encoder is not initialized");
    return -1;
  }
 
  if (!pcm_data || !opus_data || frame_size <= 0 || max_opus_bytes <= 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid Opus encoder buffers or lengths");
    return -1;
  }
 
  int encoded_bytes = opus_encode(g_opus_encoder, pcm_data, frame_size, opus_data, max_opus_bytes);
  if (encoded_bytes < 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Opus encoding failed: %s", opus_strerror(encoded_bytes));
    return -1;
  }
 
  return encoded_bytes;
}

References ERROR_INVALID_PARAM, ERROR_INVALID_STATE, and SET_ERRNO.

Referenced by OpusCodecBinding::encode().

client_opus_encoder_cleanup()

void client_opus_encoder_cleanup

(

void

)

Cleanup Opus encoder

Definition at line 971 of file src/web/client.c.

                                       {
  if (g_opus_encoder) {
    opus_encoder_destroy(g_opus_encoder);
    g_opus_encoder = NULL;
  }
}

Referenced by OpusCodecBinding::OpusCodecBinding(), and OpusCodecBinding::~OpusCodecBinding().

client_opus_encoder_init()

int client_opus_encoder_init	(	int	sample_rate,
		int	channels,
		int	bitrate )

Initialize Opus encoder

Parameters

sample_rate	Sample rate (8000, 16000, 24000, or 48000)
channels	Number of channels (1=mono, 2=stereo)
bitrate	Target bitrate in bits/sec

Returns

0 on success, -1 on error

Definition at line 864 of file src/web/client.c.

                                                                         {
  if (g_opus_encoder) {
    opus_encoder_destroy(g_opus_encoder);
    g_opus_encoder = NULL;
  }
 
  int error;
  g_opus_encoder = opus_encoder_create(sample_rate, channels,
                                       bitrate >= 128000 ? OPUS_APPLICATION_AUDIO : OPUS_APPLICATION_VOIP, &error);
  if (error != OPUS_OK || !g_opus_encoder) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Cannot initialize Opus encoder: %s", opus_strerror(error));
    return -1;
  }
 
  // Set bitrate
  if (opus_encoder_ctl(g_opus_encoder, OPUS_SET_BITRATE(bitrate)) != OPUS_OK) {
    opus_encoder_destroy(g_opus_encoder);
    g_opus_encoder = NULL;
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid Opus encoder bitrate: %d", bitrate);
    return -1;
  }
 
  return 0;
}

References ERROR_INVALID_PARAM, OPUS_APPLICATION_AUDIO, OPUS_APPLICATION_VOIP, and SET_ERRNO.

Referenced by OpusCodecBinding::OpusCodecBinding().

client_parse_gpg_private_key()

int client_parse_gpg_private_key	(	const char *	armored_key,
		uint8_t *	secret_key_out )

Parse an unencrypted armored OpenPGP Ed25519 private key through the shared C parser.

Definition at line 316 of file src/web/client.c.

                                                                                   {
  if (!armored_key || !secret_key_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid OpenPGP private key input or output");
    return -1;
  }
  uint8_t public_key[crypto_sign_PUBLICKEYBYTES] = {0};
  uint8_t seed[crypto_sign_SEEDBYTES] = {0};
  uint8_t derived_public_key[crypto_sign_PUBLICKEYBYTES] = {0};
  uint8_t secret_key[crypto_sign_SECRETKEYBYTES] = {0};
  int result = -1;
 
  if (openpgp_parse_armored_seckey(armored_key, public_key, seed) != ASCIICHAT_OK)
    goto cleanup;
  if (crypto_sign_seed_keypair(derived_public_key, secret_key, seed) != 0 ||
      sodium_memcmp(derived_public_key, public_key, sizeof(public_key)) != 0) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "OpenPGP private key does not match its Ed25519 public key");
    goto cleanup;
  }
 
  memcpy(secret_key_out, secret_key, sizeof(secret_key));
  result = 0;
 
cleanup:
  sodium_memzero(public_key, sizeof(public_key));
  sodium_memzero(seed, sizeof(seed));
  sodium_memzero(derived_public_key, sizeof(derived_public_key));
  sodium_memzero(secret_key, sizeof(secret_key));
  return result;
}

References ASCIICHAT_OK, ERROR_CRYPTO_KEY, ERROR_INVALID_PARAM, openpgp_parse_armored_seckey(), and SET_ERRNO.

client_parse_gpg_private_key_binary()

int client_parse_gpg_private_key_binary	(	const uint8_t *	key_data,
		size_t	key_data_len,
		uint8_t *	secret_key_out )

Parse an unencrypted binary OpenPGP Ed25519 secret-key packet stream.

Definition at line 347 of file src/web/client.c.

                                                                                                               {
  if (!key_data || key_data_len == 0 || !secret_key_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid binary OpenPGP private key input or output");
    return -1;
  }
  uint8_t public_key[crypto_sign_PUBLICKEYBYTES] = {0};
  uint8_t seed[crypto_sign_SEEDBYTES] = {0};
  uint8_t derived_public_key[crypto_sign_PUBLICKEYBYTES] = {0};
  uint8_t secret_key[crypto_sign_SECRETKEYBYTES] = {0};
  int result = -1;
 
  if (openpgp_parse_binary_seckey(key_data, key_data_len, public_key, seed) != ASCIICHAT_OK)
    goto cleanup;
  if (crypto_sign_seed_keypair(derived_public_key, secret_key, seed) != 0 ||
      sodium_memcmp(derived_public_key, public_key, sizeof(public_key)) != 0) {
    SET_ERRNO(ERROR_CRYPTO_KEY, "OpenPGP private key does not match its Ed25519 public key");
    goto cleanup;
  }
 
  memcpy(secret_key_out, secret_key, sizeof(secret_key));
  result = 0;
 
cleanup:
  sodium_memzero(public_key, sizeof(public_key));
  sodium_memzero(seed, sizeof(seed));
  sodium_memzero(derived_public_key, sizeof(derived_public_key));
  sodium_memzero(secret_key, sizeof(secret_key));
  return result;
}

References ASCIICHAT_OK, ERROR_CRYPTO_KEY, ERROR_INVALID_PARAM, openpgp_parse_binary_seckey(), and SET_ERRNO.

client_parse_gpg_public_key()

int client_parse_gpg_public_key	(	const char *	armored_key,
		uint8_t *	public_key_out )

Parse an armored OpenPGP Ed25519 public key through the shared C parser.

Definition at line 298 of file src/web/client.c.

                                                                                  {
  if (!armored_key || !public_key_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid OpenPGP public key input or output");
    return -1;
  }
  return openpgp_parse_armored_pubkey(armored_key, public_key_out) == ASCIICHAT_OK ? 0 : -1;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, openpgp_parse_armored_pubkey(), and SET_ERRNO.

client_parse_gpg_public_key_binary()

int client_parse_gpg_public_key_binary	(	const uint8_t *	key_data,
		size_t	key_data_len,
		uint8_t *	public_key_out )

Parse a binary OpenPGP Ed25519 public-key packet stream.

Definition at line 307 of file src/web/client.c.

                                                                                                              {
  if (!key_data || key_data_len == 0 || !public_key_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid binary OpenPGP public key input or output");
    return -1;
  }
  return openpgp_parse_binary_pubkey(key_data, key_data_len, public_key_out) == ASCIICHAT_OK ? 0 : -1;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, openpgp_parse_binary_pubkey(), and SET_ERRNO.

client_parse_ssh_private_key()

int client_parse_ssh_private_key	(	const char *	key_path,
		uint8_t *	secret_key_out )

Parse an OpenSSH Ed25519 private-key file through the shared SSH parser.

Definition at line 265 of file src/web/client.c.

                                                                                {
  if (!key_path || !secret_key_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SSH private key input or output");
    return -1;
  }
#ifdef EMSCRIPTEN_BUILD
  static const char wasm_key_prefix[] = "/tmp/ascii-chat-key-";
  if (strncmp(key_path, wasm_key_prefix, sizeof(wasm_key_prefix) - 1) != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid browser SSH private key path");
    return -1;
  }
#endif
  private_key_t key = {0};
  asciichat_error_t result = parse_ssh_private_key(key_path, &key);
  if (result != ASCIICHAT_OK || key.type != KEY_TYPE_ED25519 || key.use_ssh_agent || key.use_gpg_agent) {
    sodium_memzero(&key, sizeof(key));
    return -1;
  }
  memcpy(secret_key_out, key.key.ed25519, crypto_sign_SECRETKEYBYTES);
  sodium_memzero(&key, sizeof(key));
  return 0;
}

References ASCIICHAT_OK, private_key_t::ed25519, ERROR_INVALID_PARAM, private_key_t::key, KEY_TYPE_ED25519, parse_ssh_private_key(), SET_ERRNO, private_key_t::type, private_key_t::use_gpg_agent, and private_key_t::use_ssh_agent.

client_parse_ssh_public_key()

int client_parse_ssh_public_key	(	const char *	key_line,
		uint8_t *	public_key_out )

Parse an OpenSSH Ed25519 public-key line through the shared SSH parser.

Definition at line 289 of file src/web/client.c.

                                                                               {
  if (!key_line || !public_key_out) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid SSH public key input or output");
    return -1;
  }
  return parse_ssh_ed25519_line(key_line, public_key_out) == ASCIICHAT_OK ? 0 : -1;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, parse_ssh_ed25519_line(), and SET_ERRNO.

client_public_key_bytes()

const uint8_t * client_public_key_bytes

(

void

)

Definition at line 514 of file src/web/client.c.

                                             {
  if (g_crypto_handshake_ctx.state == CRYPTO_HANDSHAKE_DISABLED) {
    SET_ERRNO(ERROR_INVALID_STATE, "Client handshake is not initialized");
    return NULL;
  }
  return g_crypto_handshake_ctx.crypto_ctx.public_key;
}

References CRYPTO_HANDSHAKE_DISABLED, ERROR_INVALID_STATE, and SET_ERRNO.

client_resolve_crypto_policy()

int client_resolve_crypto_policy	(	bool	secure,
		int	encryption )

Resolve browser inputs through the same policy as native and mobile clients.

Definition at line 1009 of file src/web/client.c.

                                                              {
  crypto_policy_t policy = {
      .transport_secure = secure,
      .encrypt = encryption == 1,
      .no_encrypt = encryption == 0,
      .has_password = g_crypto_password[0] != '\0',
      .has_identity = g_has_client_identity_key,
      .has_verification_key = g_has_expected_server_identity_key,
  };
  uint8_t mode;
  if (crypto_policy_resolve(&policy, &mode) != ASCIICHAT_OK)
    return -1;
  g_crypto_mode = mode;
  return mode;
}

References ASCIICHAT_OK, and crypto_policy_resolve().

Referenced by EMSCRIPTEN_BINDINGS().

client_security_context()

crypto_context_t * client_security_context

(

void

)

Definition at line 1110 of file src/web/client.c.

                                                {
  return g_handshake_complete ? &g_crypto_handshake_ctx.crypto_ctx : NULL;
}

client_set_server_address()

int client_set_server_address	(	const char *	server_host,
		int	server_port )

Set server address for known_hosts verification

Parameters

server_host	Server hostname or IP address
server_port	Server port number

Returns

0 on success, -1 on error

Definition at line 496 of file src/web/client.c.

                                                                        {
  if (!g_initialized) {
    SET_ERRNO(ERROR_INVALID_STATE, "Client is not initialized");
    return -1;
  }
 
  if (!server_host || !server_host[0] || server_port <= 0 || server_port > 65535) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid client server address or port");
    return -1;
  }
 
  // Set server IP and port in handshake context
  SAFE_STRNCPY(g_crypto_handshake_ctx.server_ip, server_host, sizeof(g_crypto_handshake_ctx.server_ip));
  g_crypto_handshake_ctx.server_port = server_port;
 
  return 0;
}

References ERROR_INVALID_PARAM, ERROR_INVALID_STATE, SAFE_STRNCPY, and SET_ERRNO.

client_settings_receive()

asciichat_error_t client_settings_receive	(	const void *	payload,
		size_t	length )

Effective remote state is separate from this participant's saved preferences.

Definition at line 21 of file src/web/client.c.

                                                                              {
  acip_settings_header_t header;
  const char *json;
  size_t json_length;
  asciichat_error_t result = acip_settings_decode(payload, length, &header, &json, &json_length);
  if (result != ASCIICHAT_OK)
    return result;
  options_t *current = SAFE_MALLOC(sizeof(*current), options_t *),
            *candidate = SAFE_MALLOC(sizeof(*candidate), options_t *);
  // Browser capability packets and the shared renderer always support UTF-8.
  remote_render_settings.caps.utf8_support = true;
  acip_render_settings_options(&remote_render_settings, current);
  result = options_prepare_json(current, json, json_length, candidate, true);
  if (result == ASCIICHAT_OK)
    result = acip_render_settings_prepare(&remote_render_settings, candidate);
  if (result == ASCIICHAT_OK)
    remote_render_settings.revision = header.revision;
  SAFE_FREE(current);
  SAFE_FREE(candidate);
  return result;
}

References acip_render_settings_options(), acip_render_settings_prepare(), acip_settings_decode(), ASCIICHAT_OK, options_prepare_json(), SAFE_FREE, and SAFE_MALLOC.

client_settings_values()

char * client_settings_values

(

void

)

Definition at line 42 of file src/web/client.c.

                                   {
  options_t *values = SAFE_MALLOC(sizeof(*values), options_t *);
  acip_render_settings_options(&remote_render_settings, values);
  char *json = options_values_json(values, true);
  SAFE_FREE(values);
  return json;
}

References acip_render_settings_options(), options_values_json(), SAFE_FREE, and SAFE_MALLOC.

client_validate_frame()

asciichat_error_t client_validate_frame	(	const char *	text,
		size_t	length,
		uint32_t	width,
		uint32_t	height,
		uint32_t	checksum,
		uint32_t	flags,
		const void *	metadata,
		size_t	metadata_length )

Definition at line 1075 of file src/web/client.c.

                                                                {
  if (flags & ~(FRAME_FLAG_RENDER_CONTRACT | FRAME_FLAG_IS_COMPRESSED | 1u))
    return SET_ERRNO(ERROR_INVALID_FRAME, "Unknown browser frame flags");
  acip_render_settings_t settings;
  uint32_t effects = 0;
  bool contract = (flags & FRAME_FLAG_RENDER_CONTRACT) != 0;
  if (contract) {
    size_t consumed;
    asciichat_error_t decoded = frame_render_contract_decode(metadata, metadata_length, &settings, &effects, &consumed);
    if (decoded != ASCIICHAT_OK)
      return decoded;
    if (settings.revision && settings.revision == remote_render_settings.revision &&
        remote_render_settings.palette[0] && remote_render_settings.caps.utf8_support &&
        strcmp(settings.palette, remote_render_settings.palette) != 0)
      return SET_ERRNO(ERROR_INVALID_FRAME, "Browser frame palette contradicts acknowledged revision");
    if (consumed != metadata_length)
      return SET_ERRNO(ERROR_INVALID_FRAME, "Trailing browser frame contract bytes");
  } else if (metadata_length) {
    return SET_ERRNO(ERROR_INVALID_FRAME, "Unexpected browser frame contract");
  }
  if (!text || !length || length > FRAME_RENDER_MAX_BYTES || asciichat_crc32(text, length) != checksum)
    return SET_ERRNO(ERROR_INVALID_FRAME, "Browser frame length/checksum mismatch");
  return session_frame_validate_contract(text, length, width, height, contract ? &settings : NULL, effects);
}

References asciichat_crc32, ASCIICHAT_OK, ERROR_INVALID_FRAME, FRAME_FLAG_IS_COMPRESSED, FRAME_FLAG_RENDER_CONTRACT, frame_render_contract_decode(), FRAME_RENDER_MAX_BYTES, height, acip_render_settings_t::palette, acip_render_settings_t::revision, session_frame_validate_contract(), SET_ERRNO, and width.