server.h File Reference

Go to the source code of this file.

Data Structures
struct	acds_client_data_t
	Per-client connection data. More...
struct	migration_context_t
	In-memory host migration context. More...
struct	acds_stats_t
	Network statistics for both TCP and WebSocket connections. More...
struct	acds_server_t
	Discovery server state. More...

Functions
asciichat_error_t	acds_server_init (acds_server_t *server, const acds_config_t *config)
	Initialize discovery server.
void	acds_server_shutdown (acds_server_t *server)
	Shutdown discovery server.
void *	acds_client_handler (void *arg)
	Per-client connection handler (thread entry point)
void *	acds_websocket_client_handler (void *arg)
	WebSocket client handler (thread entry point)

Function Documentation

acds_client_handler()

void * acds_client_handler

(

void *

arg

)

Per-client connection handler (thread entry point)

Processes ACIP packets from a connected client. Handles crypto handshake, then dispatches packets to session/signaling handlers.

Parameters

arg	Pointer to client connection context

Returns

NULL (thread exit value)

Definition at line 967 of file src/discovery-service/server.c.

                                     {
  tcp_client_context_t *ctx = (tcp_client_context_t *)arg;
  if (!ctx) {
    log_error("Client handler: NULL context");
    return NULL;
  }
 
  acds_server_t *server = (acds_server_t *)ctx->user_data;
  socket_t client_socket = ctx->client_socket;
 
  // Get client IP for logging
  char client_ip[INET6_ADDRSTRLEN] = {0};
  tcp_client_context_get_ip(ctx, client_ip, sizeof(client_ip));
 
  log_info("Client handler started for %s", client_ip);
 
  // Register client in TCP server registry with allocated client data
  acds_client_data_t *client_data = SAFE_MALLOC(sizeof(acds_client_data_t), acds_client_data_t *);
  if (!client_data) {
    tcp_server_reject_client(client_socket, "Failed to allocate client data");
    SAFE_FREE(ctx);
    return NULL;
  }
  memset(client_data, 0, sizeof(*client_data));
  client_data->joined_session = false;
  client_data->handshake_complete = false;
 
  // Initialize crypto handshake context with client IP name
  char crypto_name[96];
  SAFE_SNPRINTF(crypto_name, sizeof(crypto_name), "crypto_discovery_client_%s", client_ip);
  asciichat_error_t handshake_result = crypto_handshake_init(crypto_name, &client_data->handshake_ctx, true);
  if (handshake_result != ASCIICHAT_OK) {
    log_error("Failed to initialize crypto handshake for client %s", client_ip);
    SAFE_FREE(client_data);
    tcp_server_reject_client(client_socket, "Failed to initialize crypto handshake");
    SAFE_FREE(ctx);
    return NULL;
  }
 
  // Set server identity keys for handshake
  client_data->handshake_ctx.server_public_key.type = KEY_TYPE_ED25519;
  client_data->handshake_ctx.server_private_key.type = KEY_TYPE_ED25519;
  memcpy(client_data->handshake_ctx.server_public_key.key, server->identity_public, 32);
  memcpy(client_data->handshake_ctx.server_private_key.key.ed25519, server->identity_secret, 64);
 
  if (tcp_server_add_client(server->tcp_server, client_socket, client_data) != ASCIICHAT_OK) {
    SAFE_FREE(client_data);
    tcp_server_reject_client(client_socket, "Failed to register client in registry");
    SAFE_FREE(ctx);
    return NULL;
  }
 
  log_debug("Client %s registered (socket=%d, total=%zu)", client_ip, client_socket,
            tcp_server_get_client_count(server->tcp_server));
 
  // Create transport for handshake and subsequent client communication
  acip_transport_t *transport = acip_tcp_transport_create("acds_tcp_client", client_socket, NULL);
  if (!transport) {
    log_error("Failed to create TCP transport for client %s", client_ip);
    tcp_server_remove_client(server->tcp_server, client_socket);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  // Perform crypto handshake using shared server_like implementation
  log_debug("Performing crypto handshake with client %s", client_ip);
  handshake_result = session_server_like_handshake(&client_data->handshake_ctx, transport);
  if (handshake_result != ASCIICHAT_OK) {
    log_warn("Crypto handshake failed for client %s", client_ip);
    acip_transport_destroy(transport);
    tcp_server_remove_client(server->tcp_server, client_socket);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  client_data->handshake_complete = true;
  log_info("Crypto handshake complete for client %s", client_ip);
 
  // Store transport and registry ID in client data, and link back from transport
  client_data->transport = transport;
  client_data->registry_id = client_socket;
  transport->user_data = client_data;
 
  // Main packet processing loop
  uint64_t last_packet_time_ns = time_get_ns();
  const uint64_t idle_disconnect_ns = 60ULL * NS_PER_SEC_INT; // Disconnect after 60s idle
 
  while (atomic_load_bool(&server->tcp_server->running)) {
    packet_type_t packet_type;
    void *payload = NULL;
    size_t payload_size = 0;
 
    // Receive packet (blocking with system timeout)
    int result = receive_packet(client_socket, &packet_type, &payload, &payload_size);
 
    if (result >= 0) {
      last_packet_time_ns = time_get_ns();
      log_info("★ ACDS_CLIENT_HANDLER: Received packet type=%u from %s, payload_size=%zu", packet_type, client_ip,
               payload_size);
 
      // Track network stats (TCP packets)
      // Packet size includes header (6 bytes: magic 4 + type 1 + length 2 + CRC 4)
      size_t total_packet_size = payload_size + 14; // 4 (magic) + 1 (type) + 2 (length) + 4 (CRC) + 3 (client ID)
      atomic_fetch_add_u64(&server->stats.bytes_received, total_packet_size);
      atomic_fetch_add_u64(&server->stats.packets_received, 1);
    }
 
    if (result < 0) {
      // Check error context to distinguish timeout from actual disconnect
      asciichat_error_context_t err_ctx;
      bool has_context = HAS_ERRNO(&err_ctx);
 
      // Check if this is a timeout (non-fatal) or actual disconnect (fatal)
      asciichat_error_t error = GET_ERRNO();
      if (error == ERROR_NETWORK_TIMEOUT ||
          (error == ERROR_NETWORK && has_context && strstr(err_ctx.context_message, "timed out") != NULL)) {
        // Check if client has been idle too long (abrupt disconnect without FIN)
        uint64_t idle_ns = time_get_ns() - last_packet_time_ns;
        if (idle_ns >= idle_disconnect_ns) {
          log_info("Client %s: idle for %llu seconds, disconnecting", client_ip,
                   (unsigned long long)(idle_ns / NS_PER_SEC_INT));
          if (payload) {
            buffer_pool_free(NULL, payload, payload_size);
          }
          break;
        }
        log_debug("Client %s: receive timeout, continuing to wait for packets", client_ip);
        if (payload) {
          buffer_pool_free(NULL, payload, payload_size);
        }
        continue;
      }
 
      // Actual disconnect or fatal error
      log_info("Client %s disconnected", client_ip);
      if (payload) {
        buffer_pool_free(NULL, payload, payload_size);
      }
      break;
    }
 
    log_debug("Received packet type 0x%02X from %s, length=%zu", packet_type, client_ip, payload_size);
 
    // Multi-key session creation protocol: block non-PING/PONG/SESSION_CREATE messages
    if (client_data->in_multikey_session_create) {
      bool allowed = (packet_type == PACKET_TYPE_ACIP_SESSION_CREATE || packet_type == PACKET_TYPE_PING ||
                      packet_type == PACKET_TYPE_PONG);
 
      if (!allowed) {
        log_warn("Client %s sent packet type 0x%02X during multi-key session creation - only SESSION_CREATE/PING/PONG "
                 "allowed",
                 client_ip, packet_type);
 
        // Send error response using persistent transport
        acip_send_error(transport, ERROR_INVALID_PARAM,
                        "Only SESSION_CREATE/PING/PONG allowed during multi-key session creation");
 
        // Free payload and continue
        if (payload) {
          buffer_pool_free(NULL, payload, payload_size);
        }
        continue;
      }
    }
 
    // O(1) ACIP array-based dispatch
    // Set server context for callbacks
    acip_acds_callbacks_t callbacks = g_acds_callbacks;
    callbacks.app_ctx = server;
 
    asciichat_error_t dispatch_result =
        acip_handle_acds_packet(transport, packet_type, payload, payload_size, client_ip, &callbacks);
 
    if (dispatch_result != ASCIICHAT_OK) {
      log_warn("ACIP handler failed for packet type 0x%02X from %s: %s", packet_type, client_ip,
               asciichat_error_string(dispatch_result));
    }
 
    // Free payload (allocated by receive_packet via buffer_pool_alloc)
    if (payload) {
      buffer_pool_free(NULL, payload, payload_size);
    }
 
    // Keep handler running after session_established
    // Handler continues to receive and relay WebRTC signaling packets (SDP, ICE)
    // Broadcasts don't go through this socket - they use tcp_server_foreach_client() to write directly
  }
 
  // Cleanup - handler always cleans up since it runs until connection closes
  if (client_data->joined_session) {
    asciichat_error_t leave_result = acds_remove_client_from_session(server, client_data);
    if (leave_result != ASCIICHAT_OK) {
      log_warn("Could not clean up disconnected participant %02x%02x...: %s", client_data->participant_id[0],
               client_data->participant_id[1], asciichat_error_string(leave_result));
    }
  }
  tcp_server_remove_client(server->tcp_server, client_socket);
  log_debug("Client %s unregistered (total=%zu)", client_ip, tcp_server_get_client_count(server->tcp_server));
 
  // Destroy transport before closing socket
  acip_transport_destroy(transport);
  socket_close(client_socket);
 
  SAFE_FREE(ctx);
 
  log_info("Client handler finished for %s", client_ip);
  return NULL;
}

References acip_handle_acds_packet(), acip_send_error(), acip_tcp_transport_create(), acip_transport_destroy(), acip_acds_callbacks_t::app_ctx, ASCIICHAT_OK, atomic_fetch_add_u64(), atomic_load_bool(), buffer_pool_free(), acds_stats_t::bytes_received, tcp_client_context_t::client_socket, asciichat_error_context_t::context_message, crypto_handshake_init(), private_key_t::ed25519, ERROR_INVALID_PARAM, ERROR_NETWORK, ERROR_NETWORK_TIMEOUT, GET_ERRNO, acds_client_data_t::handshake_complete, acds_client_data_t::handshake_ctx, HAS_ERRNO, acds_server_t::identity_public, acds_server_t::identity_secret, acds_client_data_t::in_multikey_session_create, acds_client_data_t::joined_session, public_key_t::key, private_key_t::key, KEY_TYPE_ED25519, log_debug, log_error, log_info, log_warn, NS_PER_SEC_INT, PACKET_TYPE_ACIP_SESSION_CREATE, PACKET_TYPE_PING, PACKET_TYPE_PONG, acds_stats_t::packets_received, acds_client_data_t::participant_id, receive_packet(), acds_client_data_t::registry_id, tcp_server::running, SAFE_FREE, SAFE_MALLOC, SAFE_SNPRINTF, crypto_handshake_context_t::server_private_key, crypto_handshake_context_t::server_public_key, session_server_like_handshake(), socket_close(), acds_server_t::stats, tcp_client_context_get_ip(), acds_server_t::tcp_server, tcp_server_add_client(), tcp_server_get_client_count(), tcp_server_reject_client(), tcp_server_remove_client(), time_get_ns(), acds_client_data_t::transport, public_key_t::type, private_key_t::type, acip_transport::user_data, and tcp_client_context_t::user_data.

Referenced by acds_main().

acds_server_init()

asciichat_error_t acds_server_init	(	acds_server_t *	server,
		const acds_config_t *	config
	)

Initialize discovery server.

Loads or generates identity keys, opens database, creates session registry, and binds TCP socket.

Parameters

server	Server structure to initialize
config	Configuration from command-line parsing

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 194 of file src/discovery-service/server.c.

                                                                                       {
  if (!server || !config) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server or config is NULL");
  }
 
  memset(server, 0, sizeof(*server));
  memcpy(&server->config, config, sizeof(acds_config_t));
 
  // Initialize stats
  atomic_store_u64(&server->stats.bytes_sent, 0);
  atomic_store_u64(&server->stats.bytes_received, 0);
  atomic_store_u64(&server->stats.packets_sent, 0);
  atomic_store_u64(&server->stats.packets_received, 0);
  server->stats.start_time = time(NULL);
 
  // Open database (SQLite as single source of truth)
  asciichat_error_t result = database_init(config->database_path, &server->db);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  // Initialize rate limiter with SQLite backend
  server->rate_limiter = rate_limiter_create_sqlite(NULL); // NULL = externally managed DB
  if (!server->rate_limiter) {
    database_close(server->db);
    return SET_ERRNO(ERROR_MEMORY, "Failed to create rate limiter");
  }
 
  // Set the database handle for the rate limiter
  rate_limiter_set_sqlite_db(server->rate_limiter, server->db);
 
  // Get TCP server from server_like (it owns the lifecycle)
  server->tcp_server = session_server_like_get_tcp_server();
  if (!server->tcp_server) {
    rate_limiter_destroy(server->rate_limiter);
    database_close(server->db);
    return SET_ERRNO(ERROR_INVALID_STATE, "TCP server not available from server_like");
  }
 
  // Initialize background worker thread pool
  atomic_store_bool(&server->shutdown, false);
  server->worker_pool = thread_pool_create("acds_workers");
  if (!server->worker_pool) {
    log_warn("Failed to create worker thread pool");
    rate_limiter_destroy(server->rate_limiter);
    database_close(server->db);
    return SET_ERRNO(ERROR_MEMORY, "Failed to create worker thread pool");
  }
 
  // Spawn cleanup thread in worker pool
  if (thread_pool_spawn(server->worker_pool, cleanup_thread_func, server, 0, "cleanup") != ASCIICHAT_OK) {
    log_warn("Failed to spawn cleanup thread (continuing without cleanup)");
  }
 
  log_info("Discovery server initialized successfully");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, atomic_store_bool(), atomic_store_u64(), acds_stats_t::bytes_received, acds_stats_t::bytes_sent, acds_server_t::config, database_close(), database_init(), acds_config_t::database_path, acds_server_t::db, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, ERROR_MEMORY, log_info, log_warn, acds_stats_t::packets_received, acds_stats_t::packets_sent, acds_server_t::rate_limiter, rate_limiter_create_sqlite(), rate_limiter_destroy(), rate_limiter_set_sqlite_db(), session_server_like_get_tcp_server(), SET_ERRNO, acds_server_t::shutdown, acds_stats_t::start_time, acds_server_t::stats, acds_server_t::tcp_server, thread_pool_create(), thread_pool_spawn(), and acds_server_t::worker_pool.

acds_server_shutdown()

void acds_server_shutdown

(

acds_server_t *

server

)

Shutdown discovery server.

Closes listen socket, stops accepting connections, waits for handler threads to exit, closes database, and frees resources.

Parameters

server

Server structure to clean up

Definition at line 252 of file src/discovery-service/server.c.

                                                 {
  if (!server) {
    return;
  }
 
  // Signal shutdown to worker threads
  atomic_store_bool(&server->shutdown, true);
 
  // Wait for all client handler threads to exit
  // TCP server is still alive (server_like destroys it after cleanup_fn)
  if (server->tcp_server) {
    size_t remaining_clients;
    int shutdown_attempts = 0;
    const int max_shutdown_attempts = 100; // 10 seconds (100 * 100ms)
 
    while ((remaining_clients = tcp_server_get_client_count(server->tcp_server)) > 0 &&
           shutdown_attempts < max_shutdown_attempts) {
      log_debug("Waiting for %zu client handler threads to exit (attempt %d/%d)", remaining_clients,
                shutdown_attempts + 1, max_shutdown_attempts);
      APP_CALLBACK_VOID(platform_pump_events);
      platform_sleep_ms(100);
      shutdown_attempts++;
    }
 
    if (remaining_clients > 0) {
      log_warn("Server shutdown: %zu client handler threads still running after 10 seconds", remaining_clients);
    } else if (shutdown_attempts > 0) {
      log_debug("All client handler threads exited gracefully");
    }
  }
 
  // Stop and destroy worker thread pool (cleanup thread, etc.)
  if (server->worker_pool) {
    thread_pool_destroy(server->worker_pool);
    server->worker_pool = NULL;
    log_debug("Worker thread pool stopped");
  }
 
  // Destroy rate limiter
  if (server->rate_limiter) {
    rate_limiter_destroy(server->rate_limiter);
    server->rate_limiter = NULL;
  }
 
  // Close database
  if (server->db) {
    database_close(server->db);
    server->db = NULL;
  }
 
  log_info("Server shutdown complete");
}

References APP_CALLBACK_VOID, atomic_store_bool(), database_close(), acds_server_t::db, log_debug, log_info, log_warn, platform_sleep_ms(), acds_server_t::rate_limiter, rate_limiter_destroy(), acds_server_t::shutdown, acds_server_t::tcp_server, tcp_server_get_client_count(), thread_pool_destroy(), and acds_server_t::worker_pool.

acds_websocket_client_handler()

void * acds_websocket_client_handler

(

void *

arg

)

WebSocket client handler (thread entry point)

Processes ACIP packets from a WebSocket client connection. Similar to TCP handler but uses transport-based APIs for crypto handshake.

Parameters

arg	Pointer to websocket_client_context_t

Returns

NULL (thread exit value)

Definition at line 1210 of file src/discovery-service/server.c.

                                               {
  websocket_client_context_t *ctx = (websocket_client_context_t *)arg;
  if (!ctx) {
    log_error("WebSocket client handler: NULL context");
    return NULL;
  }
 
  acds_server_t *server = (acds_server_t *)ctx->user_data;
  acip_transport_t *transport = ctx->transport;
  char *client_ip = ctx->client_ip;
 
  log_info("WebSocket client handler started for %s", client_ip);
 
  // Allocate client_data
  acds_client_data_t *client_data = SAFE_CALLOC(1, sizeof(acds_client_data_t), acds_client_data_t *);
  if (!client_data) {
    log_error("Failed to allocate client data for WebSocket client %s", client_ip);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  client_data->transport = transport;
  client_data->joined_session = false;
  client_data->handshake_complete = false;
  transport->user_data = client_data;
 
  // Initialize crypto handshake context with client IP name
  char crypto_name[96];
  SAFE_SNPRINTF(crypto_name, sizeof(crypto_name), "crypto_discovery_websocket_%s", client_ip);
  asciichat_error_t hs_init_result = crypto_handshake_init(crypto_name, &client_data->handshake_ctx, true);
  if (hs_init_result != ASCIICHAT_OK) {
    log_error("Failed to initialize crypto handshake for WebSocket client %s", client_ip);
    SAFE_FREE(client_data);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  // Set server identity keys for handshake
  client_data->handshake_ctx.server_public_key.type = KEY_TYPE_ED25519;
  client_data->handshake_ctx.server_private_key.type = KEY_TYPE_ED25519;
  memcpy(client_data->handshake_ctx.server_public_key.key, server->identity_public, 32);
  memcpy(client_data->handshake_ctx.server_private_key.key.ed25519, server->identity_secret, 64);
 
  // Generate synthetic socket ID for tcp_server registry
  static _Atomic int g_ws_synthetic_id = INT_MAX;
  int synthetic_id = atomic_fetch_sub(&g_ws_synthetic_id, 1);
  client_data->registry_id = synthetic_id;
 
  // Register in tcp_server with synthetic ID (so callbacks can find client_data)
  if (tcp_server_add_client(server->tcp_server, synthetic_id, client_data) != ASCIICHAT_OK) {
    log_error("Failed to register WebSocket client %s in registry", client_ip);
    SAFE_FREE(client_data);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  log_debug("WebSocket client %s registered (synthetic_id=%d, total=%zu)", client_ip, synthetic_id,
            tcp_server_get_client_count(server->tcp_server));
 
  // Determine if client authentication is required by checking server configuration
  bool auth_required = server->config.require_client_identity;
  ctx->auth_required = auth_required;
 
  // Plain WebSocket signaling requires the ACIP crypto handshake. TLS can
  // replace application encryption when identity authentication is not needed.
  bool skip_handshake = ctx->is_secure && !auth_required;
 
  if (skip_handshake) {
    client_data->handshake_complete = true;
    log_info("Secure WebSocket connection from %s - using TLS without custom crypto handshake", client_ip);
  } else {
    log_info("WebSocket connection from %s - proceeding with crypto handshake%s", client_ip,
             auth_required ? " (client authentication required)" : "");
 
    // Perform crypto handshake using shared server_like implementation
    log_debug("Performing crypto handshake with WebSocket client %s", client_ip);
    asciichat_error_t hs_result = session_server_like_handshake(&client_data->handshake_ctx, transport);
    if (hs_result != ASCIICHAT_OK) {
      log_warn("Crypto handshake failed for WebSocket client %s", client_ip);
      tcp_server_remove_client(server->tcp_server, synthetic_id);
      SAFE_FREE(ctx);
      return NULL;
    }
 
    client_data->handshake_complete = true;
    log_debug("Crypto handshake completed for WebSocket client %s", client_ip);
    transport->crypto_ctx = &client_data->handshake_ctx.crypto_ctx;
  }
 
  // Main packet processing loop using transport recv
  while (atomic_load_bool(&server->tcp_server->running)) {
    void *recv_buffer = NULL;
    size_t recv_len = 0;
    void *alloc_buffer = NULL;
 
    asciichat_error_t recv_result = acds_receive_websocket_packet(transport, &recv_buffer, &recv_len, &alloc_buffer);
    if (recv_result != ASCIICHAT_OK) {
      // Check if this is a timeout or disconnect
      if (recv_result == ERROR_NETWORK_TIMEOUT) {
        log_debug("WebSocket client %s: receive timeout, continuing to wait for packets", client_ip);
        if (alloc_buffer) {
          buffer_pool_free(NULL, alloc_buffer, 0);
        }
        continue;
      }
 
      // Actual disconnect or fatal error
      log_info("WebSocket client %s disconnected", client_ip);
      if (alloc_buffer) {
        buffer_pool_free(NULL, alloc_buffer, 0);
      }
      break;
    }
 
    // Parse packet header from received data
    if (recv_len < sizeof(packet_header_t)) {
      log_warn("WebSocket client %s: received packet too small (%zu bytes)", client_ip, recv_len);
      if (alloc_buffer) {
        buffer_pool_free(NULL, alloc_buffer, 0);
      }
      continue;
    }
 
    const packet_header_t *header = (const packet_header_t *)recv_buffer;
    packet_type_t packet_type = (packet_type_t)NET_TO_HOST_U16(header->type);
    size_t payload_size = NET_TO_HOST_U32(header->length);
    const void *payload = (const uint8_t *)recv_buffer + sizeof(packet_header_t);
 
    // Validate payload size
    if (recv_len < sizeof(packet_header_t) + payload_size) {
      log_warn("WebSocket client %s: packet size mismatch (expected %zu, got %zu)", client_ip,
               sizeof(packet_header_t) + payload_size, recv_len);
      if (alloc_buffer) {
        buffer_pool_free(NULL, alloc_buffer, 0);
      }
      continue;
    }
 
    log_debug("Received packet type 0x%02X from WebSocket client %s, length=%zu", packet_type, client_ip, payload_size);
 
    // Multi-key session creation protocol: block non-PING/PONG/SESSION_CREATE messages
    if (client_data->in_multikey_session_create) {
      bool allowed = (packet_type == PACKET_TYPE_ACIP_SESSION_CREATE || packet_type == PACKET_TYPE_PING ||
                      packet_type == PACKET_TYPE_PONG);
 
      if (!allowed) {
        log_warn("WebSocket client %s sent packet type 0x%02X during multi-key session creation - only "
                 "SESSION_CREATE/PING/PONG allowed",
                 client_ip, packet_type);
        acip_send_error(transport, ERROR_INVALID_PARAM,
                        "Only SESSION_CREATE/PING/PONG allowed during multi-key session creation");
        if (alloc_buffer) {
          buffer_pool_free(NULL, alloc_buffer, 0);
        }
        continue;
      }
    }
 
    // O(1) ACIP array-based dispatch
    acip_acds_callbacks_t callbacks = g_acds_callbacks;
    callbacks.app_ctx = server;
 
    asciichat_error_t dispatch_result =
        acip_handle_acds_packet(transport, packet_type, payload, payload_size, client_ip, &callbacks);
 
    if (dispatch_result != ASCIICHAT_OK) {
      log_warn("ACIP handler failed for packet type 0x%02X from WebSocket client %s: %s", packet_type, client_ip,
               asciichat_error_string(dispatch_result));
    }
 
    if (alloc_buffer) {
      buffer_pool_free(NULL, alloc_buffer, 0);
    }
  }
 
  // Cleanup
  if (client_data->joined_session) {
    asciichat_error_t leave_result = acds_remove_client_from_session(server, client_data);
    if (leave_result != ASCIICHAT_OK) {
      log_warn("Could not clean up disconnected WebSocket participant %02x%02x...: %s", client_data->participant_id[0],
               client_data->participant_id[1], asciichat_error_string(leave_result));
    }
  }
  tcp_server_remove_client(server->tcp_server, synthetic_id);
  log_debug("WebSocket client %s unregistered (total=%zu)", client_ip, tcp_server_get_client_count(server->tcp_server));
 
  // Transport is owned by WebSocket server, don't destroy it here
 
  log_info("WebSocket client handler finished for %s", client_ip);
 
  SAFE_FREE(ctx);
 
  return NULL;
}

References acip_handle_acds_packet(), acip_send_error(), acip_acds_callbacks_t::app_ctx, ASCIICHAT_OK, atomic_load_bool(), websocket_client_context_t::auth_required, buffer_pool_free(), websocket_client_context_t::client_ip, acds_server_t::config, crypto_handshake_context_t::crypto_ctx, acip_transport::crypto_ctx, crypto_handshake_init(), private_key_t::ed25519, ERROR_INVALID_PARAM, ERROR_NETWORK_TIMEOUT, acds_client_data_t::handshake_complete, acds_client_data_t::handshake_ctx, acds_server_t::identity_public, acds_server_t::identity_secret, acds_client_data_t::in_multikey_session_create, websocket_client_context_t::is_secure, acds_client_data_t::joined_session, public_key_t::key, private_key_t::key, KEY_TYPE_ED25519, packet_header_t::length, log_debug, log_error, log_info, log_warn, NET_TO_HOST_U16, NET_TO_HOST_U32, PACKET_TYPE_ACIP_SESSION_CREATE, PACKET_TYPE_PING, PACKET_TYPE_PONG, acds_client_data_t::participant_id, acds_client_data_t::registry_id, acds_config_t::require_client_identity, tcp_server::running, SAFE_CALLOC, SAFE_FREE, SAFE_SNPRINTF, crypto_handshake_context_t::server_private_key, crypto_handshake_context_t::server_public_key, session_server_like_handshake(), acds_server_t::tcp_server, tcp_server_add_client(), tcp_server_get_client_count(), tcp_server_remove_client(), websocket_client_context_t::transport, acds_client_data_t::transport, public_key_t::type, private_key_t::type, packet_header_t::type, acip_transport::user_data, and websocket_client_context_t::user_data.

Referenced by acds_main().