lib/network/client.c

Go to the documentation of this file.

 
#include <ascii-chat/network/client.h>
#include <ascii-chat/network/connection_handle.h>
#include <ascii-chat/common.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/platform/abstraction.h>
#include <ascii-chat/debug/named.h>
 
#include <string.h>
#include <ascii-chat/atomic.h>
 
app_client_t *app_client_create(void) {
  app_client_t *client = SAFE_MALLOC(sizeof(app_client_t), app_client_t *);
  if (!client) {
    log_error("Failed to allocate app_client_t");
    return NULL;
  }
 
  // Zero-initialize all fields
  memset(client, 0, sizeof(*client));
 
  /* Transport */
  connection_handle_init(&client->connection);
 
  /* Audio State */
  memset(&client->audio_ctx, 0, sizeof(client->audio_ctx));
  memset(client->audio_send_queue, 0, sizeof(client->audio_send_queue));
  client->audio_send_queue_head = 0;
  client->audio_send_queue_tail = 0;
  client->audio_send_queue_initialized = false;
  atomic_store_bool(&client->audio_sender_should_exit, false);
  client->audio_capture_thread_created = false;
  client->audio_sender_thread_created = false;
  atomic_store_bool(&client->audio_capture_thread_exited, false);
 
  // Initialize audio queue mutex and condition variable
  if (mutex_init(&client->audio_send_queue_mutex, "audio_queue") != 0) {
    log_error("Failed to initialize audio queue mutex");
    SAFE_FREE(client);
    return NULL;
  }
 
  if (cond_init(&client->audio_send_queue_cond, "audio_queue") != 0) {
    log_error("Failed to initialize audio queue cond");
    mutex_destroy(&client->audio_send_queue_mutex);
    SAFE_FREE(client);
    return NULL;
  }
 
  /* Protocol State */
  client->data_thread_created = false;
  atomic_store_bool(&client->data_thread_exited, false);
  client->last_active_count = 0;
  client->server_state_initialized = false;
  client->should_clear_before_next_frame = false;
  client->my_client_id = 0;
  client->encryption_enabled = false;
 
  /* Capture State */
  client->capture_thread_created = false;
  atomic_store_bool(&client->capture_thread_exited, false);
 
  /* Keepalive State */
  client->ping_thread_created = false;
  atomic_store_bool(&client->ping_thread_exited, false);
 
  /* Display State */
  client->has_tty = false;
  atomic_store_bool(&client->is_first_frame_of_connection, false);
  memset(&client->tty_info, 0, sizeof(client->tty_info));
 
  /* Crypto State */
  memset(&client->crypto_ctx, 0, sizeof(client->crypto_ctx));
  client->crypto_initialized = false;
 
  // Register atomic fields for sync state monitoring with fully descriptive names
  char atomic_name[256];
 
  // Audio subsystem control and status
  snprintf(atomic_name, sizeof(atomic_name), "app_client.audio_sender_thread_should_exit_signal");
  NAMED_REGISTER_ATOMIC(&client->audio_sender_should_exit, atomic_name, NULL);
 
  snprintf(atomic_name, sizeof(atomic_name), "app_client.audio_capture_thread_has_exited_status");
  NAMED_REGISTER_ATOMIC(&client->audio_capture_thread_exited, atomic_name, NULL);
 
  // Protocol and network data handling
  snprintf(atomic_name, sizeof(atomic_name), "app_client.protocol_data_dispatch_thread_has_exited_status");
  NAMED_REGISTER_ATOMIC(&client->data_thread_exited, atomic_name, NULL);
 
  // Media capture control and status
  snprintf(atomic_name, sizeof(atomic_name), "app_client.media_capture_thread_has_exited_status");
  NAMED_REGISTER_ATOMIC(&client->capture_thread_exited, atomic_name, NULL);
 
  // Keepalive and connection health monitoring
  snprintf(atomic_name, sizeof(atomic_name), "app_client.keepalive_ping_thread_has_exited_status");
  NAMED_REGISTER_ATOMIC(&client->ping_thread_exited, atomic_name, NULL);
 
  // Display frame sequencing
  snprintf(atomic_name, sizeof(atomic_name), "app_client.is_first_frame_of_new_connection_flag");
  NAMED_REGISTER_ATOMIC(&client->is_first_frame_of_connection, atomic_name, NULL);
 
  log_debug("App client created");
 
  return client;
}
 
void app_client_destroy(app_client_t **client_ptr) {
  if (!client_ptr || !*client_ptr) {
    return; // No-op if NULL
  }
 
  app_client_t *client = *client_ptr;
 
  log_debug("Destroying app client");
 
  // Unregister atomic fields
  NAMED_UNREGISTER(&client->audio_sender_should_exit);
  NAMED_UNREGISTER(&client->audio_capture_thread_exited);
  NAMED_UNREGISTER(&client->data_thread_exited);
  NAMED_UNREGISTER(&client->capture_thread_exited);
  NAMED_UNREGISTER(&client->ping_thread_exited);
  NAMED_UNREGISTER(&client->is_first_frame_of_connection);
 
  // Destroy mutexes and condition variables
  mutex_destroy(&client->audio_send_queue_mutex);
  cond_destroy(&client->audio_send_queue_cond);
 
  connection_handle_cleanup(&client->connection);
 
  SAFE_FREE(*client_ptr);
}