client.c File Reference

Go to the source code of this file.

Macros
#define	WASM_LOG(msg)   EM_ASM({ console.error('[C] ' + UTF8ToString($0)); }, msg)
#define	WASM_LOG_INT(msg, val)   EM_ASM({ console.error('[C] ' + UTF8ToString($0) + ': ' + $1); }, msg, val)
#define	WASM_ERROR(msg)   EM_ASM({ console.error('[C] ERROR: ' + UTF8ToString($0)); }, msg)

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);})
EMSCRIPTEN_KEEPALIVE int	client_init_with_args (const char *args_json)
EMSCRIPTEN_KEEPALIVE void	client_cleanup (void)
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_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)
EMSCRIPTEN_KEEPALIVE const char *	get_help_text (int mode, const char *option_name)

Macro Definition Documentation

WASM_ERROR

#define WASM_ERROR

(

msg

)

EM_ASM({ console.error('[C] ERROR: ' + UTF8ToString($0)); }, msg)

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

WASM_LOG

#define WASM_LOG

(

msg

)

EM_ASM({ console.error('[C] ' + UTF8ToString($0)); }, msg)

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

WASM_LOG_INT

#define WASM_LOG_INT	(		msg,
			val
	)		EM_ASM({ console.error('[C] ' + UTF8ToString($0) + ': ' + $1); }, msg, val)

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

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 121 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_cleanup()

EMSCRIPTEN_KEEPALIVE void client_cleanup

(

void

)

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

                          {
  WASM_LOG("=== client_cleanup CALLED ===");
  WASM_LOG_INT("  g_initialized", g_initialized);
  WASM_LOG_INT("  g_connection_state", g_connection_state);
  WASM_LOG_INT("  g_crypto_handshake_ctx.state", g_crypto_handshake_ctx.state);
 
  // 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();
 
  WASM_LOG("=== client_cleanup COMPLETE ===");
}

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

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

                                           {
  if (!g_handshake_complete) {
    WASM_ERROR("Decryption requires completed handshake");
    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) {
    WASM_ERROR("Decryption failed");
    return -1;
  }
 
  *out_len = plaintext_len;
  return 0;
}

References crypto_decrypt(), and WASM_ERROR.

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

                                           {
  if (!g_handshake_complete) {
    WASM_ERROR("Encryption requires completed handshake");
    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) {
    WASM_ERROR("Encryption failed");
    return -1;
  }
 
  *out_len = ciphertext_len;
  return 0;
}

References crypto_encrypt(), and WASM_ERROR.

client_free_string()

EMSCRIPTEN_KEEPALIVE void client_free_string

(

char *

ptr

)

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

                                   {
  SAFE_FREE(ptr);
}

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

                                  {
  WASM_LOG("=== client_generate_keypair CALLED ===");
  WASM_LOG_INT("  g_initialized", g_initialized);
  WASM_LOG_INT("  g_crypto_handshake_ctx.state BEFORE", g_crypto_handshake_ctx.state);
 
  if (!g_initialized) {
    WASM_ERROR("Client not initialized");
    return -1;
  }
 
  // Reset handshake context if previously used (reconnection / React Strict Mode remount)
  if (g_crypto_handshake_ctx.state != CRYPTO_HANDSHAKE_DISABLED) {
    WASM_LOG("Destroying previous handshake context before re-init");
    WASM_LOG_INT("  State before destroy", g_crypto_handshake_ctx.state);
    crypto_handshake_destroy(&g_crypto_handshake_ctx);
    WASM_LOG_INT("  State after destroy", g_crypto_handshake_ctx.state);
    memset(&g_crypto_handshake_ctx, 0, sizeof(g_crypto_handshake_ctx));
    WASM_LOG_INT("  State after memset", g_crypto_handshake_ctx.state);
    g_handshake_complete = false;
  }
 
  // Initialize crypto handshake context
  WASM_LOG("Calling crypto_handshake_init...");
  WASM_LOG_INT("  State before init", g_crypto_handshake_ctx.state);
  asciichat_error_t result = crypto_handshake_init(&g_crypto_handshake_ctx, false /* is_server */);
  if (result != ASCIICHAT_OK) {
    WASM_LOG_INT("crypto_handshake_init FAILED, result", result);
    WASM_LOG_INT("  State after failed init", g_crypto_handshake_ctx.state);
    return -1;
  }
 
  WASM_LOG("Keypair generated successfully");
  WASM_LOG_INT("  g_crypto_handshake_ctx.state AFTER init", g_crypto_handshake_ctx.state);
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
  return 0;
}

References CONNECTION_STATE_DISCONNECTED, crypto_handshake_destroy(), crypto_handshake_init(), WASM_ERROR, WASM_LOG, and WASM_LOG_INT.

client_get_connection_state()

EMSCRIPTEN_KEEPALIVE int client_get_connection_state

(

void

)

Get current connection state

Returns

Connection state enum value

Definition at line 716 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 302 of file src/web/client.c.

                                      {
  if (g_crypto_handshake_ctx.state == CRYPTO_HANDSHAKE_DISABLED) {
    WASM_ERROR("No crypto context (call client_generate_keypair first)");
    return NULL;
  }
 
  // Get public key from handshake context
  const uint8_t *pubkey = g_crypto_handshake_ctx.crypto_ctx.public_key;
  if (!pubkey) {
    WASM_ERROR("Public key not available in crypto context");
    return NULL;
  }
 
  // Allocate buffer for hex string (32 bytes = 64 hex chars + null terminator)
  char *hex_buffer = SAFE_MALLOC(65, char *);
  if (!hex_buffer) {
    WASM_ERROR("Failed to allocate 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 WASM_ERROR.

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

                                                                           {
  WASM_LOG("=== client_handle_auth_challenge CALLED ===");
  WASM_LOG_INT("  packet_len", (int)packet_len);
  WASM_LOG_INT("  g_crypto_handshake_ctx.state", g_crypto_handshake_ctx.state);
 
  if (!packet || packet_len == 0) {
    WASM_ERROR("Invalid packet data");
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    WASM_ERROR("Packet too small for 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);
 
  WASM_LOG_INT("  packet_type", packet_type);
  WASM_LOG_INT("  payload_len", (int)payload_len);
 
  // 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) {
      WASM_ERROR("Failed to allocate payload buffer");
      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);
 
  WASM_LOG_INT("  auth_response result", result);
 
  if (result != ASCIICHAT_OK) {
    WASM_ERROR("Failed to process AUTH_CHALLENGE");
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  WASM_LOG("=== AUTH_CHALLENGE processed successfully ===");
  return 0;
}

References buffer_pool_alloc(), CONNECTION_STATE_ERROR, crypto_handshake_client_auth_response(), WASM_ERROR, WASM_LOG, and WASM_LOG_INT.

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

                                                                               {
  WASM_LOG("=== client_handle_handshake_complete CALLED ===");
  WASM_LOG_INT("  packet_len", (int)packet_len);
  WASM_LOG_INT("  g_crypto_handshake_ctx.state", g_crypto_handshake_ctx.state);
 
  if (!packet || packet_len == 0) {
    WASM_ERROR("Invalid packet data");
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    WASM_ERROR("Packet too small for 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);
 
  WASM_LOG_INT("  packet_type", packet_type);
 
  // 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) {
      WASM_ERROR("Failed to allocate payload buffer");
      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);
 
  WASM_LOG_INT("  handshake_complete result", result);
 
  if (result != ASCIICHAT_OK) {
    WASM_ERROR("Failed to complete handshake");
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  g_handshake_complete = true;
  g_connection_state = CONNECTION_STATE_CONNECTED;
  WASM_LOG("=== HANDSHAKE COMPLETE - session encrypted ===");
  return 0;
}

References buffer_pool_alloc(), CONNECTION_STATE_CONNECTED, CONNECTION_STATE_ERROR, crypto_handshake_client_complete(), WASM_ERROR, WASM_LOG, and WASM_LOG_INT.

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

                                                                              {
  WASM_LOG("=== client_handle_key_exchange_init CALLED ===");
  WASM_LOG_INT("  packet_len", (int)packet_len);
  WASM_LOG_INT("  g_crypto_handshake_ctx.state BEFORE", g_crypto_handshake_ctx.state);
 
  // 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) {
    WASM_LOG("Handshake context not in INIT state, reinitializing...");
    WASM_LOG_INT("  Previous state", g_crypto_handshake_ctx.state);
 
    // 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(&g_crypto_handshake_ctx, false);
    if (init_result != ASCIICHAT_OK) {
      WASM_ERROR("Failed to reinitialize crypto handshake context");
      WASM_LOG_INT("  init result", init_result);
      return -1;
    }
    WASM_LOG("Crypto handshake context reinitialized");
  }
 
  if (!packet || packet_len == 0) {
    WASM_ERROR("Invalid packet data");
    return -1;
  }
 
  // Extract packet type and payload
  if (packet_len < sizeof(packet_header_t)) {
    WASM_ERROR("Packet too small for 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);
 
  WASM_LOG_INT("  packet_type", packet_type);
  WASM_LOG_INT("  payload_len", (int)payload_len);
 
  // 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) {
      WASM_ERROR("Failed to allocate payload buffer");
      g_connection_state = CONNECTION_STATE_ERROR;
      return -1;
    }
    memcpy(payload, payload_src, payload_len);
  }
 
  // Process key exchange using transport-abstracted handshake
  WASM_LOG("Calling crypto_handshake_client_key_exchange...");
 
  asciichat_error_t result = crypto_handshake_client_key_exchange(&g_crypto_handshake_ctx, &g_wasm_transport,
                                                                  packet_type, payload, payload_len);
 
  WASM_LOG_INT("  handshake result", result);
  WASM_LOG_INT("  g_crypto_handshake_ctx.state AFTER", g_crypto_handshake_ctx.state);
 
  if (result != ASCIICHAT_OK) {
    WASM_ERROR("Failed to process KEY_EXCHANGE_INIT");
    g_connection_state = CONNECTION_STATE_ERROR;
    return -1;
  }
 
  g_connection_state = CONNECTION_STATE_HANDSHAKE;
  WASM_LOG("=== KEY_EXCHANGE_INIT processed successfully ===");
  return 0;
}

References buffer_pool_alloc(), CONNECTION_STATE_ERROR, CONNECTION_STATE_HANDSHAKE, crypto_handshake_client_key_exchange(), crypto_handshake_destroy(), crypto_handshake_init(), WASM_ERROR, WASM_LOG, and WASM_LOG_INT.

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

                                                 {
  // Parse arguments
  WASM_LOG("Parsing arguments...");
  char *args_copy = strdup(args_json);
  if (!args_copy) {
    WASM_ERROR("strdup FAILED");
    return -1;
  }
 
  // Count arguments
  int argc = 0;
  char *argv[64] = {NULL}; // Max 64 arguments
  char *token = strtok(args_copy, " ");
  while (token != NULL && argc < 63) {
    argv[argc++] = token;
    token = strtok(NULL, " ");
  }
  argv[argc] = NULL;
  WASM_LOG_INT("Parsed arguments, argc", argc);
 
  // Initialize options (sets up RCU, defaults, etc.)
  WASM_LOG("Calling options_init...");
  asciichat_error_t err = options_init(argc, argv);
  free(args_copy);
  WASM_LOG("client_init_with_args: START");
 
  if (g_initialized) {
    WASM_ERROR("Client already initialized");
    return -1;
  }
 
  // Initialize platform layer
  WASM_LOG("Calling platform_init...");
  err = platform_init();
  if (err != ASCIICHAT_OK) {
    WASM_ERROR("platform_init FAILED");
    return -1;
  }
  WASM_LOG("platform_init OK");
 
  // Initialize logging to stderr (console.error in browser)
  WASM_LOG("Calling log_init...");
  log_init(NULL, LOG_DEBUG, true, false);
  WASM_LOG("log_init OK");
  log_info("WASM client initialized via logging system");
 
  if (err != ASCIICHAT_OK) {
    WASM_LOG_INT("options_init FAILED", err);
    return -1;
  }
  WASM_LOG("options_init OK");
 
  // Initialize ANSI color code generation
  WASM_LOG("Calling ansi_fast_init...");
  ansi_fast_init();
  WASM_LOG("ansi_fast_init OK");
 
  g_initialized = true;
  g_connection_state = CONNECTION_STATE_DISCONNECTED;
 
  WASM_LOG("client_init_with_args: COMPLETE");
  return 0;
}

References ansi_fast_init(), CONNECTION_STATE_DISCONNECTED, log_init(), options_init(), platform_init(), WASM_ERROR, WASM_LOG, and WASM_LOG_INT.

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

                                                                                                                    {
  if (!g_opus_decoder) {
    WASM_ERROR("Opus decoder not initialized");
    return -1;
  }
 
  int decoded_samples = opus_decode(g_opus_decoder, opus_data, opus_bytes, pcm_data, frame_size, decode_fec);
  if (decoded_samples < 0) {
    WASM_ERROR("Opus decoding failed");
    return -1;
  }
 
  return decoded_samples;
}

References WASM_ERROR.

client_opus_decoder_cleanup()

EMSCRIPTEN_KEEPALIVE void client_opus_decoder_cleanup

(

void

)

Cleanup Opus decoder

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

                                       {
  if (g_opus_decoder) {
    opus_decoder_destroy(g_opus_decoder);
    g_opus_decoder = NULL;
    WASM_LOG("Opus decoder cleaned up");
  }
}

References WASM_LOG.

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 768 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) {
    WASM_ERROR("Failed to create Opus decoder");
    return -1;
  }
 
  WASM_LOG("Opus decoder initialized");
  return 0;
}

References WASM_ERROR, and WASM_LOG.

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

                                                                                                        {
  if (!g_opus_encoder) {
    WASM_ERROR("Opus encoder not initialized");
    return -1;
  }
 
  int encoded_bytes = opus_encode(g_opus_encoder, pcm_data, frame_size, opus_data, max_opus_bytes);
  if (encoded_bytes < 0) {
    WASM_ERROR("Opus encoding failed");
    return -1;
  }
 
  return encoded_bytes;
}

References WASM_ERROR.

client_opus_encoder_cleanup()

EMSCRIPTEN_KEEPALIVE void client_opus_encoder_cleanup

(

void

)

Cleanup Opus encoder

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

                                       {
  if (g_opus_encoder) {
    opus_encoder_destroy(g_opus_encoder);
    g_opus_encoder = NULL;
    WASM_LOG("Opus encoder cleaned up");
  }
}

References WASM_LOG.

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 741 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) {
    WASM_ERROR("Failed to create Opus encoder");
    return -1;
  }
 
  // Set bitrate
  opus_encoder_ctl(g_opus_encoder, OPUS_SET_BITRATE(bitrate));
 
  WASM_LOG("Opus encoder initialized");
  return 0;
}

References WASM_ERROR, and WASM_LOG.

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

                                                                        {
  if (!raw_packet || packet_len < sizeof(packet_header_t)) {
    WASM_ERROR("Invalid packet data");
    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) {
    WASM_ERROR("Invalid packet magic number");
    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);
 
  // Build JSON response with packet metadata
  char *json = SAFE_MALLOC(1024, char *);
  if (!json) {
    WASM_ERROR("Failed to allocate JSON buffer");
    return NULL;
  }
 
  snprintf(json, 1024, "{\"type\":%u,\"length\":%u,\"client_id\":%u,\"crc32\":%u}", type, length, client_id, crc32);
 
  return json;
}

References WASM_ERROR.

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

                                                                             {
  if (!g_initialized) {
    WASM_ERROR("Client not 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
 
  WASM_LOG("Video frame processing not yet implemented");
  return 0;
}

References WASM_ERROR, and WASM_LOG.

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

                                                              {
  if (!output || !out_len) {
    WASM_ERROR("Invalid output parameters");
    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(), and WASM_ERROR.

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) {
    WASM_ERROR("Client not initialized");
    return -1;
  }
 
  if (!server_host || server_port <= 0 || server_port > 65535) {
    WASM_ERROR("Invalid server address parameters");
    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;
 
  WASM_LOG("Server address set");
  return 0;
}

References WASM_ERROR, and WASM_LOG.

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_help_text()

EMSCRIPTEN_KEEPALIVE const char * get_help_text	(	int	mode,
		const char *	option_name
	)

Get help text for an option in a specific mode Exported for web client to retrieve tooltips for settings

Parameters

mode	The mode (0=server, 1=client, 2=mirror, etc.)
option_name	The long name of the option (e.g., "color-mode", "fps")

Returns

Help text string, or NULL if option doesn't apply to mode

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

                                                             {
  if (!option_name || !option_name[0]) {
    return NULL;
  }
 
  // Convert int mode to asciichat_mode_t
  asciichat_mode_t mode_enum = (asciichat_mode_t)mode;
 
  // Call the C API function
  return options_get_help_text(mode_enum, option_name);
}

References options_get_help_text().