Connection Keepalive

💓 Ping/pong keepalive and timeout detection More...

Files
file	keepalive.c
	💓 Client keepalive: periodic ping/pong exchange for reliable connection failure detection
file	keepalive.h
	ascii-chat Client Connection Keepalive Management Interface

Functions
int	keepalive_start_thread ()
	Start keepalive/ping thread.
void	keepalive_stop_thread ()
	Stop keepalive/ping thread.
bool	keepalive_thread_exited ()
	Check if keepalive thread has exited.

Detailed Description

💓 Ping/pong keepalive and timeout detection

Connection Keepalive

Overview

The keepalive subsystem manages connection liveness by sending periodic ping packets and detecting pong timeouts to identify dead connections.

Implementation: src/client/keepalive.c, src/client/keepalive.h

Configuration

Timing Parameters:

• Ping interval: 5 seconds
• Pong timeout: 30 seconds
• Timeout triggers reconnection

Keepalive Thread

static void *keepalive_thread_func(void *arg)
{
  (void)arg;
 
  time_t last_pong_time = time(NULL);
 
  while (!should_exit() && server_connection_is_active()) {
    // Send ping packet
    send_packet_to_server(PACKET_TYPE_PING, NULL, 0,
                         server_connection_get_client_id());
 
    // Wait for ping interval
    for (int i = 0; i < PING_INTERVAL_SEC * 10; i++) {
      if (!should_exit() && !server_connection_is_active()) break;
      platform_sleep_usec(100000);  // 100ms
    }
 
    // Check pong timeout
    time_t now = time(NULL);
    if (now - last_pong_time > PONG_TIMEOUT_SEC) {
      log_warn("Pong timeout (%d seconds) - connection may be dead", PONG_TIMEOUT_SEC);
      server_connection_lost();
      break;
    }
  }
 
  atomic_store(&g_keepalive_thread_exited, true);
  return NULL;
}

Pong Recording

void keepalive_record_pong(void)
{
  // Update last pong time (called by protocol handler)
  g_last_pong_time = time(NULL);
}

See also

src/client/keepalive.c

src/client/keepalive.h

Client Overview

Function Documentation

keepalive_start_thread()

int keepalive_start_thread

(

)

#include <keepalive.c>

Start keepalive/ping thread.

Start keepalive/ping thread

Creates and starts the ping thread for connection keepalive. Must be called after successful server connection establishment.

Returns

0 on success, negative on error

0 on success, negative on error

Definition at line 233 of file keepalive.c.

                             {
  if (g_ping_thread_created) {
    log_warn("Ping thread already created");
    return 0;
  }
 
  // Start ping thread for keepalive
  atomic_store(&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;
}

References g_client_worker_pool, and thread_pool_spawn().

Referenced by protocol_start_connection().

keepalive_stop_thread()

void keepalive_stop_thread

(

)

#include <keepalive.c>

Stop keepalive/ping thread.

Stop keepalive/ping thread

Gracefully stops the ping thread and cleans up resources. Safe to call multiple times.

Definition at line 259 of file keepalive.c.

                             {
  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(&g_ping_thread_exited)) {
    platform_sleep_ns(100 * NS_PER_MS_INT); // 100ms
    wait_count++;
  }
 
  if (!atomic_load(&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");
}

Referenced by protocol_stop_connection().

keepalive_thread_exited()

bool keepalive_thread_exited

(

)

#include <keepalive.c>

Check if keepalive thread has exited.

Check if keepalive thread has exited

Returns

true if thread has exited, false otherwise

true if thread exited, false otherwise

Definition at line 291 of file keepalive.c.

                               {
  return atomic_load(&g_ping_thread_exited);
}