server.c File Reference

Go to the source code of this file.

Macros
#define	ACDS_CREATE_TRANSPORT(socket, transport_var)
#define	ACDS_DESTROY_TRANSPORT(transport_var)   acip_transport_destroy(transport_var)

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

Macro Definition Documentation

ACDS_CREATE_TRANSPORT

#define ACDS_CREATE_TRANSPORT	(		socket,
			transport_var
	)

Value:

  acip_transport_t *transport_var = acip_tcp_transport_create(socket, NULL);                                           \
  if (!transport_var) {                                                                                                \
    log_error("Failed to create ACDS transport");                                                                      \
    return;                                                                                                            \
  }

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

                      {                                                                                                \
    log_error("Failed to create ACDS transport");                                                                      \
    return;                                                                                                            \
  }

ACDS_DESTROY_TRANSPORT

#define ACDS_DESTROY_TRANSPORT

(

transport_var

)

acip_transport_destroy(transport_var)

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

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 821 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
  asciichat_error_t handshake_result = crypto_handshake_init(&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));
 
  // Perform crypto handshake (three-step process)
  log_debug("Performing crypto handshake with client %s", client_ip);
 
  // Step 1: Start handshake (send server key, receive client key)
  handshake_result = crypto_handshake_server_start_socket(&client_data->handshake_ctx, client_socket);
  if (handshake_result != ASCIICHAT_OK) {
    log_warn("Crypto handshake start failed for client %s", client_ip);
    tcp_server_remove_client(&server->tcp_server, client_socket);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  // Step 2: Authentication challenge (if required)
  handshake_result = crypto_handshake_server_auth_challenge_socket(&client_data->handshake_ctx, client_socket);
  if (handshake_result != ASCIICHAT_OK) {
    log_warn("Crypto handshake auth challenge failed for client %s", client_ip);
    tcp_server_remove_client(&server->tcp_server, client_socket);
    SAFE_FREE(ctx);
    return NULL;
  }
 
  // Step 3: Complete handshake (verify and finalize)
  handshake_result = crypto_handshake_server_complete_socket(&client_data->handshake_ctx, client_socket);
  if (handshake_result != ASCIICHAT_OK) {
    log_warn("Crypto handshake complete failed for client %s", client_ip);
    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);
 
  // Main packet processing loop
  while (atomic_load(&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) {
      // 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)) {
        // Timeout waiting for next packet - this is normal, continue waiting
        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_ACIP_DISCOVERY_PING ||
           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
        acip_transport_t *error_transport = acip_tcp_transport_create(client_socket, NULL);
        if (error_transport) {
          acip_send_error(error_transport, ERROR_INVALID_PARAM,
                          "Only SESSION_CREATE/PING/PONG allowed during multi-key session creation");
          ACDS_DESTROY_TRANSPORT(error_transport);
        }
 
        // 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(NULL, packet_type, payload, payload_size, client_socket, 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);
    }
  }
 
  // Cleanup
  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));
 
  socket_close(client_socket);
  SAFE_FREE(ctx);
 
  log_info("Client handler finished for %s", client_ip);
  return NULL;
}

References ACDS_DESTROY_TRANSPORT, acip_handle_acds_packet(), acip_send_error(), acip_tcp_transport_create(), buffer_pool_free(), crypto_handshake_init(), crypto_handshake_server_auth_challenge_socket(), crypto_handshake_server_complete_socket(), crypto_handshake_server_start_socket(), 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, acds_client_data_t::joined_session, receive_packet(), tcp_client_context_get_ip(), acds_server_t::tcp_server, tcp_server_add_client(), tcp_server_get_client_count(), tcp_server_reject_client(), and tcp_server_remove_client().

Referenced by acds_server_init().

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 189 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));
 
  // 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);
 
  // Configure TCP server
  tcp_server_config_t tcp_config = {
      .port = config->port,
      .ipv4_address = (config->address[0] != '\0') ? config->address : NULL,
      .ipv6_address = (config->address6[0] != '\0') ? config->address6 : NULL,
      .bind_ipv4 = (config->address[0] != '\0') || (config->address[0] == '\0' && config->address6[0] == '\0'),
      .bind_ipv6 = (config->address6[0] != '\0') || (config->address[0] == '\0' && config->address6[0] == '\0'),
      .accept_timeout_sec = 1,
      .client_handler = acds_client_handler,
      .user_data = server,
  };
 
  // Initialize TCP server
  result = tcp_server_init(&server->tcp_server, &tcp_config);
  if (result != ASCIICHAT_OK) {
    rate_limiter_destroy(server->rate_limiter);
    database_close(server->db);
    return result;
  }
 
  // Initialize background worker thread pool
  atomic_store(&server->shutdown, false);
  server->worker_pool = thread_pool_create("acds_workers");
  if (!server->worker_pool) {
    log_warn("Failed to create worker thread pool");
    tcp_server_destroy(&server->tcp_server);
    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 acds_client_handler(), acds_config_t::address, acds_config_t::address6, acds_server_t::config, database_close(), database_init(), acds_config_t::database_path, acds_server_t::db, acds_config_t::port, acds_server_t::rate_limiter, rate_limiter_create_sqlite(), rate_limiter_destroy(), rate_limiter_set_sqlite_db(), acds_server_t::shutdown, acds_server_t::tcp_server, tcp_server_destroy(), tcp_server_init(), thread_pool_create(), thread_pool_spawn(), and acds_server_t::worker_pool.

Referenced by acds_main().

acds_server_run()

asciichat_error_t acds_server_run

(

acds_server_t *

server

)

Run discovery server main loop.

Accepts client connections and spawns handler threads. Blocks until shutdown signal received.

Parameters

server

Initialized server structure

Returns

ASCIICHAT_OK on success, error code otherwise

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

                                                         {
  if (!server) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server is NULL");
  }
 
  log_info("Discovery server accepting connections on port %d", server->config.port);
 
  // Delegate to TCP server abstraction
  return tcp_server_run(&server->tcp_server);
}

References acds_server_t::config, acds_config_t::port, acds_server_t::tcp_server, and tcp_server_run().

Referenced by acds_main().

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 264 of file src/discovery-service/server.c.

                                                 {
  if (!server) {
    return;
  }
 
  // Signal shutdown to worker threads
  atomic_store(&server->shutdown, true);
 
  // Shutdown TCP server (closes listen sockets, stops accept loop)
  tcp_server_destroy(&server->tcp_server);
 
  // Wait for all client handler threads to exit
  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);
    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 database_close(), acds_server_t::db, platform_sleep_ms(), acds_server_t::rate_limiter, rate_limiter_destroy(), acds_server_t::shutdown, acds_server_t::tcp_server, tcp_server_destroy(), tcp_server_get_client_count(), thread_pool_destroy(), and acds_server_t::worker_pool.

Referenced by acds_main().