client.c File Reference

Go to the source code of this file.

Enumerations
enum	connection_state_t {   CONNECTION_STATE_DISCONNECTED = 0 , CONNECTION_STATE_CONNECTING = 1 , CONNECTION_STATE_HANDSHAKE = 2 , CONNECTION_STATE_CONNECTED = 3 ,   CONNECTION_STATE_ERROR = 4 }

Functions
	EM_JS (void, js_send_raw_packet,(const uint8_t *packet_data, size_t packet_len), { if(!Module.sendPacketCallback) { console.error('[WASM] sendPacketCallback not registered - cannot send packet');return;} const packetArray=new Uint8Array(HEAPU8.buffer, packet_data, packet_len);const packetCopy=new Uint8Array(packetArray);var pktType=packetCopy.length >=10 ?((packetCopy[8]<< 8)|packetCopy[9]) :-1;console.error('[WASM->JS] Sending raw packet:', packetCopy.length, 'bytes, type=0x'+pktType.toString(16));Module.sendPacketCallback(packetCopy);})
const unsigned char *	get_font_default_ptr (void)
unsigned int	get_font_default_size (void)
EMSCRIPTEN_KEEPALIVE int	client_init_with_args (const char *args_json)
EMSCRIPTEN_KEEPALIVE void	client_cleanup (void)
EMSCRIPTEN_KEEPALIVE asciichat_error_t	client_acds_join_request (const char *session, const char *password, uint8_t *output)
EMSCRIPTEN_KEEPALIVE int	client_generate_keypair (void)
EMSCRIPTEN_KEEPALIVE int	client_set_server_address (const char *server_host, int server_port)
EMSCRIPTEN_KEEPALIVE char *	client_get_public_key_hex (void)
EMSCRIPTEN_KEEPALIVE int	client_handle_key_exchange_init (const uint8_t *packet, size_t packet_len)
EMSCRIPTEN_KEEPALIVE int	client_handle_crypto_parameters (const uint8_t *packet, size_t packet_len)
EMSCRIPTEN_KEEPALIVE int	client_handle_auth_challenge (const uint8_t *packet, size_t packet_len)
EMSCRIPTEN_KEEPALIVE int	client_handle_handshake_complete (const uint8_t *packet, size_t packet_len)
EMSCRIPTEN_KEEPALIVE int	client_encrypt_packet (const uint8_t *plaintext, size_t plaintext_len, uint8_t *ciphertext, size_t ciphertext_size, size_t *out_len)
EMSCRIPTEN_KEEPALIVE int	client_decrypt_packet (const uint8_t *ciphertext, size_t ciphertext_len, uint8_t *plaintext, size_t plaintext_size, size_t *out_len)
EMSCRIPTEN_KEEPALIVE char *	client_parse_packet (const uint8_t *raw_packet, size_t packet_len)
EMSCRIPTEN_KEEPALIVE int	client_serialize_packet (uint16_t packet_type, const uint8_t *payload, size_t payload_len, uint32_t client_id, uint8_t *output, size_t *out_len)
EMSCRIPTEN_KEEPALIVE int	client_send_video_frame (const uint8_t *rgba_data, int width, int height)
EMSCRIPTEN_KEEPALIVE int	client_get_connection_state (void)
EMSCRIPTEN_KEEPALIVE void	client_free_string (char *ptr)
EMSCRIPTEN_KEEPALIVE int	client_opus_encoder_init (int sample_rate, int channels, int bitrate)
EMSCRIPTEN_KEEPALIVE int	client_opus_decoder_init (int sample_rate, int channels)
EMSCRIPTEN_KEEPALIVE int	client_opus_encode (const int16_t *pcm_data, int frame_size, uint8_t *opus_data, int max_opus_bytes)
EMSCRIPTEN_KEEPALIVE int	client_opus_decode (const uint8_t *opus_data, int opus_bytes, int16_t *pcm_data, int frame_size, int decode_fec)
EMSCRIPTEN_KEEPALIVE void	client_opus_encoder_cleanup (void)
EMSCRIPTEN_KEEPALIVE void	client_opus_decoder_cleanup (void)

Enumeration Type Documentation

connection_state_t

enum connection_state_t

Enumerator
CONNECTION_STATE_DISCONNECTED
CONNECTION_STATE_CONNECTING
CONNECTION_STATE_HANDSHAKE
CONNECTION_STATE_CONNECTED
CONNECTION_STATE_ERROR

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

             {
  CONNECTION_STATE_DISCONNECTED = 0,
  CONNECTION_STATE_CONNECTING = 1,
  CONNECTION_STATE_HANDSHAKE = 2,
  CONNECTION_STATE_CONNECTED = 3,
  CONNECTION_STATE_ERROR = 4
} connection_state_t;

Function Documentation

client_acds_join_request()

EMSCRIPTEN_KEEPALIVE asciichat_error_t client_acds_join_request	(	const char *	session,
		const char *	password,
		uint8_t *	output
	)

Build a signed ACDS join request without exporting the ephemeral signing key.

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

                                                                                                       {
  if (!session || !password || !output || strlen(session) == 0 || strlen(session) > 47 || strlen(password) > 127) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid discovery session or password");
  }
  uint8_t public_key[crypto_sign_PUBLICKEYBYTES];
  uint8_t secret_key[crypto_sign_SECRETKEYBYTES];
  if (crypto_sign_keypair(public_key, secret_key) != 0) {
    return SET_ERRNO(ERROR_CRYPTO, "Failed to create discovery identity");
  }
  memset(output, 0, 282);
  size_t session_len = strlen(session);
  output[0] = (uint8_t)session_len;
  memcpy(output + 1, session, session_len);
  memcpy(output + 49, public_key, sizeof(public_key));
  uint64_t timestamp = (uint64_t)emscripten_date_now();
  // Packed ACDS structs use host (little-endian) fields; signatures use network order.
  memcpy(output + 145, &timestamp, sizeof(timestamp));
  uint8_t message[9 + 48];
  message[0] = (uint8_t)6004;
  for (size_t i = 0; i < 8; ++i)
    message[1 + i] = (uint8_t)(timestamp >> (56 - i * 8));
  memcpy(message + 9, session, session_len);
  int result = crypto_sign_detached(output + 81, NULL, message, 9 + session_len, secret_key);
  sodium_memzero(secret_key, sizeof(secret_key));
  if (result != 0)
    return SET_ERRNO(ERROR_CRYPTO, "Failed to sign discovery join");
  output[153] = password[0] != '\0';
  memcpy(output + 154, password, strlen(password));
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_CRYPTO, ERROR_INVALID_PARAM, and SET_ERRNO.

client_cleanup()

EMSCRIPTEN_KEEPALIVE void client_cleanup

(

void

)

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

                          {
 
  // 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_connection_state = CONNECTION_STATE_DISCONNECTED;
  g_initialized = false;
  options_state_destroy();
  platform_destroy();
}

References CONNECTION_STATE_DISCONNECTED, crypto_handshake_destroy(), options_state_destroy(), and platform_destroy().

client_decrypt_packet()

EMSCRIPTEN_KEEPALIVE 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 597 of file src/web/client.c.

                                           {
  if (!g_handshake_complete) {
    return -1;
  }
 
  // Decrypt the packet using handshake context's crypto context
  size_t plaintext_len = 0;
  crypto_result_t result = crypto_decrypt(&g_crypto_handshake_ctx.crypto_ctx, ciphertext, ciphertext_len, plaintext,
                                          plaintext_size, &plaintext_len);
  if (result != CRYPTO_OK) {
    return -1;
  }
 
  *out_len = plaintext_len;
  return 0;
}

References crypto_handshake_context_t::crypto_ctx, crypto_decrypt(), and CRYPTO_OK.

client_encrypt_packet()

EMSCRIPTEN_KEEPALIVE 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 569 of file src/web/client.c.

                                           {
  if (!g_handshake_complete) {
    return -1;
  }
 
  // Encrypt the packet using handshake context's crypto context
  size_t ciphertext_len = 0;
  crypto_result_t result = crypto_encrypt(&g_crypto_handshake_ctx.crypto_ctx, plaintext, plaintext_len, ciphertext,
                                          ciphertext_size, &ciphertext_len);
  if (result != CRYPTO_OK) {
    return -1;
  }
 
  *out_len = ciphertext_len;
  return 0;
}

References crypto_handshake_context_t::crypto_ctx, crypto_encrypt(), and CRYPTO_OK.

client_free_string()

EMSCRIPTEN_KEEPALIVE void client_free_string

(

char *

ptr

)

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

                                   {
  SAFE_FREE(ptr);
}

References SAFE_FREE.

client_generate_keypair()

EMSCRIPTEN_KEEPALIVE int client_generate_keypair

(

void

)

Generate client keypair for handshake

Returns

0 on success, -1 on error

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

                                  {
 
  if (!g_initialized) {
    return -1;
  }
 
  // 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;
  }
 
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
  return 0;
}

References ASCIICHAT_OK, CONNECTION_STATE_DISCONNECTED, crypto_handshake_destroy(), CRYPTO_HANDSHAKE_DISABLED, crypto_handshake_init(), and crypto_handshake_context_t::state.

client_get_connection_state()

EMSCRIPTEN_KEEPALIVE int client_get_connection_state

(

void

)

Get current connection state

Returns

Connection state enum value

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

                                      {
  return (int)g_connection_state;
}

client_get_public_key_hex()

EMSCRIPTEN_KEEPALIVE char * client_get_public_key_hex

(

void

)

Get client public key as hex string

Returns

Allocated hex string (caller must free with client_free_string), or NULL on error

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

                                      {
  if (g_crypto_handshake_ctx.state == CRYPTO_HANDSHAKE_DISABLED) {
    return NULL;
  }
 
  // Get public key from handshake context
  const uint8_t *pubkey = g_crypto_handshake_ctx.crypto_ctx.public_key;
  if (!pubkey) {
    return NULL;
  }
 
  // Allocate buffer for hex string (32 bytes = 64 hex chars + null terminator)
  char *hex_buffer = SAFE_MALLOC(65, char *);
  if (!hex_buffer) {
    return NULL;
  }
 
  // Convert public key to hex
  for (int i = 0; i < 32; i++) {
    snprintf(hex_buffer + (i * 2), 3, "%02x", pubkey[i]);
  }
  hex_buffer[64] = '\0';
 
  return hex_buffer;
}

References crypto_handshake_context_t::crypto_ctx, CRYPTO_HANDSHAKE_DISABLED, crypto_context_t::public_key, SAFE_MALLOC, and crypto_handshake_context_t::state.

client_handle_auth_challenge()

EMSCRIPTEN_KEEPALIVE 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 464 of file src/web/client.c.

                                                                           {
 
  if (!packet || packet_len == 0) {
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    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 pool (crypto function takes ownership and frees it)
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_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_pool_alloc(), CONNECTION_STATE_ERROR, crypto_handshake_client_auth_response(), and packet_header_t::type.

client_handle_crypto_parameters()

EMSCRIPTEN_KEEPALIVE 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 401 of file src/web/client.c.

                                                                              {
 
  if (!packet || packet_len == 0) {
    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;
    }
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    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 pool
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_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_pool_free(NULL, payload, payload_len);
  }
 
  if (result != ASCIICHAT_OK) {
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  return 0;
}

References ASCIICHAT_OK, buffer_pool_alloc(), buffer_pool_free(), CONNECTION_STATE_ERROR, crypto_handshake_destroy(), CRYPTO_HANDSHAKE_DISABLED, CRYPTO_HANDSHAKE_INIT, crypto_handshake_init(), crypto_handshake_set_parameters(), crypto_handshake_context_t::state, and packet_header_t::type.

client_handle_handshake_complete()

EMSCRIPTEN_KEEPALIVE 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 510 of file src/web/client.c.

                                                                               {
 
  if (!packet || packet_len == 0) {
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    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 pool (crypto function takes ownership and frees it)
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_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_pool_alloc(), CONNECTION_STATE_CONNECTED, CONNECTION_STATE_ERROR, crypto_handshake_context_t::crypto_ctx, acip_transport::crypto_ctx, crypto_handshake_client_complete(), and packet_header_t::type.

client_handle_key_exchange_init()

EMSCRIPTEN_KEEPALIVE 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 333 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 (!packet || packet_len == 0) {
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    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 pool (crypto function takes ownership and frees it)
  // The raw packet pointer from JS cannot be passed directly because the crypto
  // handshake function calls buffer_pool_free() on the payload when done.
  uint8_t *payload = NULL;
  if (payload_len > 0) {
    payload = buffer_pool_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_pool_alloc(), CONNECTION_STATE_ERROR, CONNECTION_STATE_HANDSHAKE, crypto_handshake_client_key_exchange(), crypto_handshake_destroy(), CRYPTO_HANDSHAKE_DISABLED, CRYPTO_HANDSHAKE_INIT, crypto_handshake_init(), crypto_handshake_context_t::state, and packet_header_t::type.

client_init_with_args()

EMSCRIPTEN_KEEPALIVE int client_init_with_args

(

const char *

args_json

)

Initialize client mode with command-line style arguments

Parameters

args_json

Space-separated string of argument strings, e.g. "client --width 80 --height 40"

Returns

0 on success, -1 on error

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

                                                 {
 
  // Parse space-separated arguments
  char *args_copy = NULL;
  char *argv[64] = {NULL};
  int argc = wasm_parse_args(args_json, argv, 64, &args_copy);
  if (argc < 0) {
    return -1;
  }
 
  // Initialize options (sets up RCU, defaults, etc.)
  asciichat_error_t err = options_init(argc, argv);
  free(args_copy);
 
  if (g_initialized) {
    return -1;
  }
 
  // Initialize platform layer
  err = platform_init();
  if (err != ASCIICHAT_OK) {
    return -1;
  }
 
  // Initialize logging to stderr (console.error in browser)
  log_init(NULL, LOG_DEBUG, true, 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, LOG_DEBUG, log_info, log_init(), log_set_format(), OPT_LOG_TEMPLATE_DEFAULT_DEBUG, options_init(), platform_init(), and wasm_parse_args().

client_opus_decode()

EMSCRIPTEN_KEEPALIVE 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 825 of file src/web/client.c.

                                                                                                                    {
  if (!g_opus_decoder) {
    return -1;
  }
 
  int decoded_samples = opus_decode(g_opus_decoder, opus_data, opus_bytes, pcm_data, frame_size, decode_fec);
  if (decoded_samples < 0) {
    return -1;
  }
 
  return decoded_samples;
}

client_opus_decoder_cleanup()

EMSCRIPTEN_KEEPALIVE void client_opus_decoder_cleanup

(

void

)

Cleanup Opus decoder

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

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

client_opus_decoder_init()

EMSCRIPTEN_KEEPALIVE 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 778 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) {
    return -1;
  }
 
  return 0;
}

client_opus_encode()

EMSCRIPTEN_KEEPALIVE 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 802 of file src/web/client.c.

                                                                                                        {
  if (!g_opus_encoder) {
    return -1;
  }
 
  int encoded_bytes = opus_encode(g_opus_encoder, pcm_data, frame_size, opus_data, max_opus_bytes);
  if (encoded_bytes < 0) {
    return -1;
  }
 
  return encoded_bytes;
}

client_opus_encoder_cleanup()

EMSCRIPTEN_KEEPALIVE void client_opus_encoder_cleanup

(

void

)

Cleanup Opus encoder

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

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

client_opus_encoder_init()

EMSCRIPTEN_KEEPALIVE 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 753 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, OPUS_APPLICATION_VOIP, &error);
  if (error != OPUS_OK || !g_opus_encoder) {
    return -1;
  }
 
  // Set bitrate
  opus_encoder_ctl(g_opus_encoder, OPUS_SET_BITRATE(bitrate));
 
  return 0;
}

References OPUS_APPLICATION_VOIP.

client_parse_packet()

EMSCRIPTEN_KEEPALIVE char * client_parse_packet	(	const uint8_t *	raw_packet,
		size_t	packet_len
	)

Parse a raw packet and return JSON metadata

Parameters

raw_packet	Raw packet bytes including header
packet_len	Length of raw packet

Returns

Allocated JSON string with packet metadata (caller must free), or NULL on error

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

                                                                        {
  if (!raw_packet || packet_len < sizeof(packet_header_t)) {
    return NULL;
  }
 
  // Parse packet header directly from bytes
  const packet_header_t *header = (const packet_header_t *)raw_packet;
 
  // Validate magic number (convert from network byte order)
  uint64_t magic = NET_TO_HOST_U64(header->magic);
  if (magic != PACKET_MAGIC) {
    return NULL;
  }
 
  // Convert header fields from network byte order
  uint16_t type = NET_TO_HOST_U16(header->type);
  uint32_t length = NET_TO_HOST_U32(header->length);
  uint32_t client_id = NET_TO_HOST_U32(header->client_id);
  uint32_t crc32 = NET_TO_HOST_U32(header->crc32);
 
  if (length != packet_len - sizeof(packet_header_t) ||
      (length > 0 && asciichat_crc32_sw(raw_packet + sizeof(packet_header_t), length) != crc32)) {
    return NULL;
  }
 
  // Build JSON response with packet metadata
  char *json = SAFE_MALLOC(1024, char *);
  if (!json) {
    return NULL;
  }
 
  snprintf(json, 1024, "{\"type\":%u,\"length\":%u,\"client_id\":%u,\"crc32\":%u}", type, length, client_id, crc32);
 
  return json;
}

References asciichat_crc32_sw(), packet_header_t::client_id, packet_header_t::crc32, packet_header_t::length, packet_header_t::magic, NET_TO_HOST_U16, NET_TO_HOST_U32, NET_TO_HOST_U64, PACKET_MAGIC, SAFE_MALLOC, and packet_header_t::type.

client_send_video_frame()

EMSCRIPTEN_KEEPALIVE int client_send_video_frame	(	const uint8_t *	rgba_data,
		int	width,
		int	height
	)

Process a video frame and prepare it for sending

Parameters

rgba_data	RGBA pixel data from canvas
width	Frame width
height	Frame height

Returns

0 on success, -1 on error

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

                                                                             {
  if (!g_initialized) {
    return -1;
  }
 
  // This is a placeholder - actual implementation would:
  // 1. Convert RGBA to target format (e.g., compress with libjpeg-turbo)
  // 2. Build frame packet
  // 3. Encrypt if handshake complete
  // 4. Return serialized packet via callback to JS
 
  return 0;
}

client_serialize_packet()

EMSCRIPTEN_KEEPALIVE int client_serialize_packet	(	uint16_t	packet_type,
		const uint8_t *	payload,
		size_t	payload_len,
		uint32_t	client_id,
		uint8_t *	output,
		size_t *	out_len
	)

Serialize a packet structure to raw bytes

Parameters

packet_type	Type of packet
payload	Packet payload data
payload_len	Length of payload
client_id	Client ID to include in header
output	Output buffer (allocated by caller)
out_len	Output parameter for total packet length

Returns

0 on success, -1 on error

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

                                                              {
  if (!output || !out_len) {
    return -1;
  }
 
  // Calculate CRC32 of payload (use software version for WASM)
  uint32_t crc = payload && payload_len > 0 ? asciichat_crc32_sw(payload, payload_len) : 0;
 
  // Build packet header (convert to network byte order)
  packet_header_t header = {.magic = HOST_TO_NET_U64(PACKET_MAGIC),
                            .type = HOST_TO_NET_U16(packet_type),
                            .length = HOST_TO_NET_U32((uint32_t)payload_len),
                            .crc32 = HOST_TO_NET_U32(crc),
                            .client_id = HOST_TO_NET_U32(client_id)};
 
  // Copy header to output
  memcpy(output, &header, sizeof(packet_header_t));
 
  // Copy payload to output
  if (payload && payload_len > 0) {
    memcpy(output + sizeof(packet_header_t), payload, payload_len);
  }
 
  *out_len = sizeof(packet_header_t) + payload_len;
  return 0;
}

References asciichat_crc32_sw(), HOST_TO_NET_U16, HOST_TO_NET_U32, HOST_TO_NET_U64, packet_header_t::magic, and PACKET_MAGIC.

client_set_server_address()

EMSCRIPTEN_KEEPALIVE 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 278 of file src/web/client.c.

                                                                        {
  if (!g_initialized) {
    return -1;
  }
 
  if (!server_host || server_port <= 0 || server_port > 65535) {
    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 SAFE_STRNCPY, crypto_handshake_context_t::server_ip, and crypto_handshake_context_t::server_port.

EM_JS()

EM_JS	(	void	,
		js_send_raw_packet	,
		(const uint8_t *packet_data, size_t packet_len)	,
		{ if(!Module.sendPacketCallback) { console.error('[WASM] sendPacketCallback not registered - cannot send packet');return;} const packetArray=new Uint8Array(HEAPU8.buffer, packet_data, packet_len);const packetCopy=new Uint8Array(packetArray);var pktType=packetCopy.length >=10 ?((packetCopy[8]<< 8)|packetCopy[9]) :-1;console.error('[WASM->JS] Sending raw packet:', packetCopy.length, 'bytes, type=0x'+pktType.toString(16));Module.sendPacketCallback(packetCopy);}
	)

get_font_default_ptr()

const unsigned char * get_font_default_ptr

(

void

)

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

                                                {
  return g_font_default;
}

References g_font_default.

get_font_default_size()

unsigned int get_font_default_size

(

void

)

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

                                         {
  return (unsigned int)g_font_default_size;
}

References g_font_default_size.