keepalive.c

Go to the documentation of this file.

 
#include "keepalive.h"
#include "main.h"
#include "../main.h" // Global exit API
#include "server.h"
#include "crypto.h"
#include <ascii-chat/util/fps.h>
#include <ascii-chat/util/time.h>
 
#include <ascii-chat/common.h>
#include <ascii-chat/app_callbacks.h>
#include <ascii-chat/platform/abstraction.h>
#include <ascii-chat/thread_pool.h>
 
#include <ascii-chat/atomic.h>
#include <ascii-chat/debug/named.h>
 
/* ============================================================================
 * Keepalive Thread Management
 * ============================================================================ */
 
static bool g_ping_thread_created = false;
 
static atomic_t g_ping_thread_exited = {0};
 
/* ============================================================================
 * Keepalive Configuration
 * ============================================================================ */
 
#define PING_INTERVAL_NS (1LL * NS_PER_SEC_INT)
 
#define PING_SLEEP_INTERVAL_NS (1LL * NS_PER_SEC_INT)
 
/* ============================================================================
 * Ping Thread Implementation
 * ============================================================================ */
 
static void *ping_thread_func(void *arg) {
  (void)arg;
 
#ifdef DEBUG_THREADS
  log_debug("Ping thread started");
#endif
 
  // FPS tracking for keepalive thread (ping sent every 1 second)
  static fps_t fps_tracker = {0};
  static bool fps_tracker_initialized = false;
  if (!fps_tracker_initialized) {
    fps_init_with_interval(&fps_tracker, 1, "KEEPALIVE",
                           100 * NS_PER_MS_INT); // Report keepalive metrics every 100ms
    fps_tracker_initialized = true;
  }
 
  // Startup grace period: Allow connection initialization to complete before checking state
  // Prevents race condition where thread spawns before transport is fully configured
  APP_CALLBACK_VOID(platform_pump_events);
  platform_sleep_ms(100);
 
  while (!should_exit() && !server_connection_is_lost()) {
    // Check if connection is still active before sending
    if (!server_connection_is_active()) {
      log_debug("Connection inactive, exiting ping thread");
      break;
    }
 
    // Check if session rekeying should be triggered
    if (crypto_client_should_rekey()) {
      log_debug("Rekey threshold reached, initiating session rekey");
      if (crypto_client_initiate_rekey() < 0) {
        log_error("Failed to initiate rekey");
        // Don't break - continue with keepalive, rekey will be retried
      }
    }
 
    // Send ping packet every PING_INTERVAL_SECONDS to keep connection alive
    // Server timeout is 5 seconds, so 3-second pings provide safety margin
    if (threaded_send_ping_packet() < 0) {
      log_debug("Failed to send ping packet");
      // Set connection lost flag so main loop knows to reconnect
      server_connection_lost();
      break;
    }
 
    // Track ping for FPS reporting
    uint64_t ping_start_ns = time_get_ns();
    fps_frame_ns(&fps_tracker, ping_start_ns, "ping sent");
 
    // Sleep with early wake capability for responsive shutdown
    // Break sleep into intervals to check shutdown flags and rekey triggers
    while (!should_exit() && !server_connection_is_lost() && server_connection_is_active()) {
      uint64_t now_ns = time_get_ns();
      uint64_t elapsed_ns = time_elapsed_ns(ping_start_ns, now_ns);
 
      if (elapsed_ns >= PING_INTERVAL_NS) {
        break; // Time for next ping
      }
 
      // Sleep for one interval or until next ping, whichever is sooner
      uint64_t remaining_ns = PING_INTERVAL_NS - elapsed_ns;
      uint64_t sleep_ns = (remaining_ns > PING_SLEEP_INTERVAL_NS) ? PING_SLEEP_INTERVAL_NS : remaining_ns;
      platform_sleep_ns(sleep_ns);
    }
  }
 
#ifdef DEBUG_THREADS
  log_debug("Ping thread stopped");
#endif
 
  atomic_store_bool(&g_ping_thread_exited, true);
 
  // Clean up thread-local error context before exit
  asciichat_errno_destroy();
 
  return NULL;
}
 
/* ============================================================================
 * Public Interface Functions
 * ============================================================================ */
 
int keepalive_start_thread() {
  if (g_ping_thread_created) {
    log_warn("Ping thread already created");
    return 0;
  }
 
  // Register keepalive atomics with named debug registry
  static bool keepalive_atomics_registered = false;
  if (!keepalive_atomics_registered) {
    NAMED_REGISTER_ATOMIC(&g_ping_thread_exited, "keepalive_ping_thread_exit_confirmation", NULL);
    keepalive_atomics_registered = true;
  }
 
  // Start ping thread for keepalive
  atomic_store_bool(&g_ping_thread_exited, false);
  if (thread_pool_spawn(g_client_worker_pool, ping_thread_func, NULL, 3, "keepalive_ping") != ASCIICHAT_OK) {
    log_error("Failed to spawn ping thread in worker pool");
    LOG_ERRNO_IF_SET("Ping thread creation failed");
    return -1;
  }
 
  g_ping_thread_created = true;
  return 0;
}
 
void keepalive_stop_thread() {
  if (!g_ping_thread_created) {
    return;
  }
 
  // Don't call signal_exit() here - that's for global shutdown only!
  // The ping thread monitors connection state and will exit when connection is lost
 
  // Wait for thread to exit gracefully
  int wait_count = 0;
  while (wait_count < 20 && !atomic_load_bool(&g_ping_thread_exited)) {
    platform_sleep_ns(100 * NS_PER_MS_INT); // 100ms
    wait_count++;
  }
 
  if (!atomic_load_bool(&g_ping_thread_exited)) {
    log_warn("Ping thread not responding - will be joined by thread pool");
  }
 
  // Thread will be joined by thread_pool_stop_all() in protocol_stop_connection()
  g_ping_thread_created = false;
 
  log_debug("Ping thread stopped and joined");
}
 
bool keepalive_thread_exited() {
  return atomic_load_bool(&g_ping_thread_exited);
}