server.c File Reference

Go to the source code of this file.

Functions
asciichat_error_t	tcp_server_init (tcp_server_t *server, const tcp_server_config_t *config)
	Initialize TCP server.
asciichat_error_t	tcp_server_run (tcp_server_t *server)
	Run TCP server accept loop.
void	tcp_server_shutdown (tcp_server_t *server)
	Shutdown TCP server.
void	tcp_server_set_cleanup_callback (tcp_server_t *server, tcp_client_cleanup_fn cleanup_fn)
	Set client cleanup callback.
asciichat_error_t	tcp_server_add_client (tcp_server_t *server, socket_t socket, void *client_data)
	Add client to registry.
asciichat_error_t	tcp_server_remove_client (tcp_server_t *server, socket_t socket)
	Remove client from registry.
asciichat_error_t	tcp_server_get_client (tcp_server_t *server, socket_t socket, void **out_data)
	Get client data.
void	tcp_server_foreach_client (tcp_server_t *server, tcp_client_foreach_fn callback, void *user_arg)
	Iterate over all clients.
size_t	tcp_server_get_client_count (tcp_server_t *server)
	Get client count.
const char *	tcp_client_context_get_ip (const tcp_client_context_t *ctx, char *buf, size_t len)
	Get formatted IP address from client context.
int	tcp_client_context_get_port (const tcp_client_context_t *ctx)
	Get port number from client context.
void	tcp_server_reject_client (socket_t socket, const char *reason)
	Reject client connection with reason.
asciichat_error_t	tcp_server_spawn_thread (tcp_server_t *server, socket_t client_socket, void *(*thread_func)(void *), void *thread_arg, int stop_id, const char *thread_name)
	Spawn a worker thread for a client.
asciichat_error_t	tcp_server_stop_client_threads (tcp_server_t *server, socket_t client_socket)
	Stop all threads for a client in stop_id order.
asciichat_error_t	tcp_server_get_thread_count (tcp_server_t *server, socket_t client_socket, size_t *count)
	Get thread count for a client.

Function Documentation

tcp_client_context_get_ip()

const char * tcp_client_context_get_ip	(	const tcp_client_context_t *	ctx,
		char *	buf,
		size_t	len
	)

Get formatted IP address from client context.

Extracts and formats the client IP address from the connection context. Works for both IPv4 and IPv6 addresses.

Parameters

ctx	Client context structure
buf	Output buffer for formatted IP string
len	Buffer size (recommend INET6_ADDRSTRLEN = 46 bytes)

Returns

Pointer to buf on success, NULL on error

Definition at line 463 of file lib/network/tcp/server.c.

                                                                                              {
  if (!ctx) {
    SET_ERRNO(ERROR_INVALID_PARAM, "ctx is NULL");
    return NULL;
  }
  if (!buf) {
    SET_ERRNO(ERROR_INVALID_PARAM, "buf is NULL");
    return NULL;
  }
  if (len == 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "len is 0");
    return NULL;
  }
 
  // Determine address family
  int addr_family = (ctx->addr.ss_family == AF_INET) ? AF_INET : AF_INET6;
 
  // Format IP address using existing utility
  if (format_ip_address(addr_family, (struct sockaddr *)&ctx->addr, buf, len) != 0) {
    return NULL;
  }
 
  return buf;
}

References tcp_client_context_t::addr, ERROR_INVALID_PARAM, format_ip_address(), and SET_ERRNO.

Referenced by acds_client_handler().

tcp_client_context_get_port()

int tcp_client_context_get_port

(

const tcp_client_context_t *

ctx

)

Get port number from client context.

Extracts the client port number from the connection context. Works for both IPv4 and IPv6 addresses.

Parameters

ctx	Client context structure

Returns

Port number (host byte order), or -1 on error

Definition at line 488 of file lib/network/tcp/server.c.

                                                                 {
  if (!ctx) {
    SET_ERRNO(ERROR_INVALID_PARAM, "ctx is NULL");
    return -1;
  }
 
  // Extract port based on address family
  if (ctx->addr.ss_family == AF_INET) {
    struct sockaddr_in *addr_in = (struct sockaddr_in *)&ctx->addr;
    return ntohs(addr_in->sin_port);
  } else if (ctx->addr.ss_family == AF_INET6) {
    struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)&ctx->addr;
    return ntohs(addr_in6->sin6_port);
  }
 
  SET_ERRNO(ERROR_INVALID_STATE, "Unknown address family: %d", ctx->addr.ss_family);
  return -1;
}

References tcp_client_context_t::addr, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, and SET_ERRNO.

tcp_server_add_client()

asciichat_error_t tcp_server_add_client	(	tcp_server_t *	server,
		socket_t	socket,
		void *	client_data
	)

Add client to registry.

Thread-safe registration of a connected client with arbitrary user data. The client_data pointer is stored as-is (caller retains ownership).

Parameters

server	Server structure
socket	Client socket (used as lookup key)
client_data	User-provided client data (can be NULL)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 337 of file lib/network/tcp/server.c.

                                                                                                  {
  if (!server) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server is NULL");
  }
 
  if (socket == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "socket is invalid");
  }
 
  // Allocate new entry
  tcp_client_entry_t *entry = SAFE_MALLOC(sizeof(tcp_client_entry_t), tcp_client_entry_t *);
  if (!entry) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate client entry");
  }
 
  entry->socket = socket;
  entry->client_data = client_data;
 
  // Create thread pool for this client
  char pool_name[64];
  SAFE_SNPRINTF(pool_name, sizeof(pool_name), "client_%d", socket);
  entry->threads = thread_pool_create(pool_name);
  if (!entry->threads) {
    SAFE_FREE(entry);
    return SET_ERRNO(ERROR_MEMORY, "Failed to create thread pool for client");
  }
 
  // Add to hash table (thread-safe)
  mutex_lock(&server->clients_mutex);
  HASH_ADD(hh, server->clients, socket, sizeof(socket_t), entry);
  mutex_unlock(&server->clients_mutex);
 
  log_debug("Added client socket=%d to registry", socket);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, tcp_client_entry::client_data, tcp_server::clients, tcp_server::clients_mutex, ERROR_INVALID_PARAM, ERROR_MEMORY, INVALID_SOCKET_VALUE, log_debug, mutex_lock, mutex_unlock, SAFE_FREE, SAFE_MALLOC, SAFE_SNPRINTF, SET_ERRNO, tcp_client_entry::socket, thread_pool_create(), and tcp_client_entry::threads.

Referenced by acds_client_handler().

tcp_server_foreach_client()

void tcp_server_foreach_client	(	tcp_server_t *	server,
		tcp_client_foreach_fn	callback,
		void *	user_arg
	)

Iterate over all clients.

Thread-safe iteration over all connected clients. The callback is called once per client while holding the clients mutex.

Parameters

server	Server structure
callback	Function to call for each client
user_arg	User argument passed to callback

Definition at line 432 of file lib/network/tcp/server.c.

                                                                                                     {
  if (!server || !callback) {
    return;
  }
 
  mutex_lock(&server->clients_mutex);
 
  tcp_client_entry_t *entry, *tmp;
  HASH_ITER(hh, server->clients, entry, tmp) {
    callback(entry->socket, entry->client_data, user_arg);
  }
 
  mutex_unlock(&server->clients_mutex);
}

References tcp_client_entry::client_data, tcp_server::clients, tcp_server::clients_mutex, mutex_lock, mutex_unlock, and tcp_client_entry::socket.

Referenced by signaling_broadcast(), signaling_relay_ice(), and signaling_relay_sdp().

tcp_server_get_client()

asciichat_error_t tcp_server_get_client	(	tcp_server_t *	server,
		socket_t	socket,
		void **	out_data
	)

Get client data.

Thread-safe lookup of client data by socket.

Parameters

server	Server structure
socket	Client socket to look up
out_data	Output pointer for client data (set to NULL if not found)

Returns

ASCIICHAT_OK if found, ERROR_NOT_FOUND if not in registry

Definition at line 410 of file lib/network/tcp/server.c.

                                                                                                {
  if (!server || !out_data) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server or out_data is NULL");
  }
 
  mutex_lock(&server->clients_mutex);
 
  tcp_client_entry_t *entry = NULL;
  HASH_FIND(hh, server->clients, &socket, sizeof(socket_t), entry);
 
  if (!entry) {
    *out_data = NULL;
    mutex_unlock(&server->clients_mutex);
    return SET_ERRNO(ERROR_INVALID_STATE, "Client socket=%d not in registry", socket);
  }
 
  *out_data = entry->client_data;
  mutex_unlock(&server->clients_mutex);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, tcp_client_entry::client_data, tcp_server::clients, tcp_server::clients_mutex, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, mutex_lock, mutex_unlock, and SET_ERRNO.

tcp_server_get_client_count()

size_t tcp_server_get_client_count

(

tcp_server_t *

server

)

Get client count.

Thread-safe count of connected clients.

Parameters

server

Server structure

Returns

Number of clients in registry

Definition at line 447 of file lib/network/tcp/server.c.

                                                         {
  if (!server) {
    return 0;
  }
 
  mutex_lock(&server->clients_mutex);
  size_t count = HASH_COUNT(server->clients);
  mutex_unlock(&server->clients_mutex);
 
  return count;
}

References tcp_server::clients, tcp_server::clients_mutex, mutex_lock, and mutex_unlock.

Referenced by acds_client_handler(), and acds_server_shutdown().

tcp_server_get_thread_count()

asciichat_error_t tcp_server_get_thread_count	(	tcp_server_t *	server,
		socket_t	client_socket,
		size_t *	count
	)

Get thread count for a client.

Thread-safe count of worker threads spawned for a client.

Parameters

	server	Server structure
	client_socket	Client socket to query
[out]	count	Output pointer for thread count (set to 0 if client not found)

Returns

ASCIICHAT_OK on success, ERROR_NOT_FOUND if client not in registry

Definition at line 588 of file lib/network/tcp/server.c.

                                                                                                           {
  if (!server || !count) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server or count is NULL");
  }
 
  if (client_socket == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "client_socket is invalid");
  }
 
  *count = 0;
 
  // Find client entry
  mutex_lock(&server->clients_mutex);
  tcp_client_entry_t *entry = NULL;
  HASH_FIND(hh, server->clients, &client_socket, sizeof(socket_t), entry);
 
  if (!entry) {
    mutex_unlock(&server->clients_mutex);
    return SET_ERRNO(ERROR_NOT_FOUND, "Client socket=%d not in registry", client_socket);
  }
 
  // Get thread count from pool
  if (entry->threads) {
    *count = thread_pool_get_count(entry->threads);
  }
 
  mutex_unlock(&server->clients_mutex);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, tcp_server::clients, tcp_server::clients_mutex, ERROR_INVALID_PARAM, ERROR_NOT_FOUND, INVALID_SOCKET_VALUE, mutex_lock, mutex_unlock, SET_ERRNO, thread_pool_get_count(), and tcp_client_entry::threads.

tcp_server_init()

asciichat_error_t tcp_server_init	(	tcp_server_t *	server,
		const tcp_server_config_t *	config
	)

Initialize TCP server.

Creates and binds TCP sockets according to configuration. At least one of IPv4 or IPv6 must be successfully bound.

Parameters

server	Server structure to initialize
config	Server configuration

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 96 of file lib/network/tcp/server.c.

                                                                                           {
  if (!server || !config) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server or config is NULL");
  }
 
  // Note: client_handler is optional - some users may use tcp_server just for socket setup
  // and implement their own accept loop (like ascii-chat server with its cleanup logic)
 
  // Initialize server state
  memset(server, 0, sizeof(*server));
  server->listen_socket = INVALID_SOCKET_VALUE;
  server->listen_socket6 = INVALID_SOCKET_VALUE;
  atomic_store(&server->running, true);
  server->config = *config; // Copy config
 
  // Initialize client registry
  server->clients = NULL; // uthash starts with NULL
  server->cleanup_fn = NULL;
  if (mutex_init(&server->clients_mutex) != 0) {
    return SET_ERRNO(ERROR_THREAD, "Failed to initialize clients mutex");
  }
 
  // Determine which IP versions to bind
  bool should_bind_ipv4 = config->bind_ipv4;
  bool should_bind_ipv6 = config->bind_ipv6;
 
  // Bind IPv4 socket if requested
  if (should_bind_ipv4) {
    const char *ipv4_addr = (config->ipv4_address && config->ipv4_address[0] != '\0') ? config->ipv4_address : NULL;
    server->listen_socket = bind_and_listen(ipv4_addr, AF_INET, config->port);
 
    if (server->listen_socket == INVALID_SOCKET_VALUE) {
      log_warn("Failed to bind IPv4 socket");
    }
  }
 
  // Bind IPv6 socket if requested
  if (should_bind_ipv6) {
    const char *ipv6_addr = (config->ipv6_address && config->ipv6_address[0] != '\0') ? config->ipv6_address : NULL;
    server->listen_socket6 = bind_and_listen(ipv6_addr, AF_INET6, config->port);
 
    if (server->listen_socket6 == INVALID_SOCKET_VALUE) {
      log_warn("Failed to bind IPv6 socket");
    }
  }
 
  // Ensure at least one socket bound successfully
  if (server->listen_socket == INVALID_SOCKET_VALUE && server->listen_socket6 == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_NETWORK_BIND, "Failed to bind any sockets (IPv4 and IPv6 both failed)");
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, tcp_server_config_t::bind_ipv4, tcp_server_config_t::bind_ipv6, tcp_server::cleanup_fn, tcp_server::clients, tcp_server::clients_mutex, tcp_server::config, ERROR_INVALID_PARAM, ERROR_NETWORK_BIND, ERROR_THREAD, INVALID_SOCKET_VALUE, tcp_server_config_t::ipv4_address, tcp_server_config_t::ipv6_address, tcp_server::listen_socket, tcp_server::listen_socket6, log_warn, mutex_init(), tcp_server_config_t::port, tcp_server::running, and SET_ERRNO.

Referenced by acds_server_init(), and server_main().

tcp_server_reject_client()

void tcp_server_reject_client	(	socket_t	socket,
		const char *	reason
	)

Reject client connection with reason.

Helper for rejecting clients due to rate limits, capacity limits, etc. Logs the rejection reason and closes the socket.

Parameters

socket	Client socket to close
reason	Human-readable rejection reason (for logging)

Definition at line 507 of file lib/network/tcp/server.c.

                                                                   {
  if (socket == INVALID_SOCKET_VALUE) {
    SET_ERRNO(ERROR_INVALID_PARAM, "socket is INVALID_SOCKET_VALUE");
    return;
  }
 
  log_warn("Rejecting client connection: %s", reason ? reason : "unknown reason");
  socket_close(socket);
}

References ERROR_INVALID_PARAM, INVALID_SOCKET_VALUE, log_warn, SET_ERRNO, and socket_close().

Referenced by acds_client_handler().

tcp_server_remove_client()

asciichat_error_t tcp_server_remove_client	(	tcp_server_t *	server,
		socket_t	socket
	)

Remove client from registry.

Thread-safe removal of a client. If a cleanup callback is set, it will be called with the client_data before removal.

Parameters

server	Server structure
socket	Client socket to remove

Returns

ASCIICHAT_OK if removed, ERROR_NOT_FOUND if not in registry

Definition at line 373 of file lib/network/tcp/server.c.

                                                                                  {
  if (!server) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server is NULL");
  }
 
  mutex_lock(&server->clients_mutex);
 
  tcp_client_entry_t *entry = NULL;
  HASH_FIND(hh, server->clients, &socket, sizeof(socket_t), entry);
 
  if (!entry) {
    mutex_unlock(&server->clients_mutex);
    // Already removed (e.g., during shutdown) - this is fine
    log_debug("Client socket=%d already removed from registry", socket);
    return ASCIICHAT_OK;
  }
 
  // Call cleanup callback if set
  if (server->cleanup_fn && entry->client_data) {
    server->cleanup_fn(entry->client_data);
  }
 
  // Destroy thread pool (stops all threads and frees resources)
  if (entry->threads) {
    thread_pool_destroy(entry->threads);
    entry->threads = NULL;
  }
 
  HASH_DEL(server->clients, entry);
  SAFE_FREE(entry);
 
  mutex_unlock(&server->clients_mutex);
 
  log_debug("Removed client socket=%d from registry", socket);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, tcp_server::cleanup_fn, tcp_client_entry::client_data, tcp_server::clients, tcp_server::clients_mutex, ERROR_INVALID_PARAM, log_debug, mutex_lock, mutex_unlock, SAFE_FREE, SET_ERRNO, thread_pool_destroy(), and tcp_client_entry::threads.

Referenced by acds_client_handler().

tcp_server_run()

asciichat_error_t tcp_server_run

(

tcp_server_t *

server

)

Run TCP server accept loop.

Accepts client connections and spawns handler threads. Blocks until server->running is set to false.

Uses select() with timeout to handle dual-stack sockets and allow responsive shutdown.

Parameters

server

Initialized server structure

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 150 of file lib/network/tcp/server.c.

                                                       {
  if (!server) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server is NULL");
  }
 
  if (!server->config.client_handler) {
    return SET_ERRNO(ERROR_INVALID_PARAM,
                     "client_handler is required for tcp_server_run() - use custom accept loop if handler is NULL");
  }
 
  log_info("TCP server starting accept loop...");
 
  while (atomic_load(&server->running)) {
    // Build fd_set for select()
    fd_set read_fds;
    socket_fd_zero(&read_fds);
    socket_t max_fd = 0;
 
    // Add IPv4 socket if available
    if (server->listen_socket != INVALID_SOCKET_VALUE) {
      socket_fd_set(server->listen_socket, &read_fds);
      max_fd = server->listen_socket > max_fd ? server->listen_socket : max_fd;
    }
 
    // Add IPv6 socket if available
    if (server->listen_socket6 != INVALID_SOCKET_VALUE) {
      socket_fd_set(server->listen_socket6, &read_fds);
      max_fd = server->listen_socket6 > max_fd ? server->listen_socket6 : max_fd;
    }
 
    // Use timeout from config (defaults to 1 second if not set)
    int timeout_sec = server->config.accept_timeout_sec > 0 ? server->config.accept_timeout_sec : 1;
    struct timeval timeout = {.tv_sec = timeout_sec, .tv_usec = 0};
 
    int select_result = socket_select((int)(max_fd + 1), &read_fds, NULL, NULL, &timeout);
 
    if (select_result < 0) {
      // Check if interrupted by signal (expected during shutdown)
      int err = socket_get_last_error();
      if (err == EINTR) {
        // Signal interrupt (e.g., SIGTERM, SIGINT) - check running flag and continue
        log_debug("select() interrupted by signal");
        continue;
      }
      // Actual error - socket_get_error_string() returns last socket error
      log_error("select() failed in accept loop: %s (errno=%d)", socket_get_error_string(), err);
      continue;
    }
 
    if (select_result == 0) {
      // Timeout - check running flag and continue
      continue;
    }
 
    // Check which socket has incoming connection
    socket_t ready_socket = INVALID_SOCKET_VALUE;
    if (server->listen_socket != INVALID_SOCKET_VALUE && socket_fd_isset(server->listen_socket, &read_fds)) {
      ready_socket = server->listen_socket;
    } else if (server->listen_socket6 != INVALID_SOCKET_VALUE && socket_fd_isset(server->listen_socket6, &read_fds)) {
      ready_socket = server->listen_socket6;
    }
 
    if (ready_socket == INVALID_SOCKET_VALUE) {
      // Spurious wakeup
      continue;
    }
 
    // Accept connection
    struct sockaddr_storage client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    socket_t client_socket = accept(ready_socket, (struct sockaddr *)&client_addr, &client_addr_len);
 
    if (client_socket == INVALID_SOCKET_VALUE) {
      log_warn("Failed to accept connection");
      continue;
    }
 
    // Format client IP for logging
    char client_ip[INET6_ADDRSTRLEN];
    int addr_family = (client_addr.ss_family == AF_INET) ? AF_INET : AF_INET6;
    if (format_ip_address(addr_family, (struct sockaddr *)&client_addr, client_ip, sizeof(client_ip)) != ASCIICHAT_OK) {
      SAFE_STRNCPY(client_ip, "(unknown)", sizeof(client_ip));
    }
 
    log_info("Accepted connection from %s", client_ip);
 
    // Allocate client context
    tcp_client_context_t *ctx = SAFE_MALLOC(sizeof(tcp_client_context_t), tcp_client_context_t *);
    if (!ctx) {
      log_error("Failed to allocate client context");
      socket_close(client_socket);
      continue;
    }
 
    ctx->client_socket = client_socket;
    ctx->addr = client_addr;
    ctx->addr_len = client_addr_len;
    ctx->user_data = server->config.user_data;
 
    // Spawn client handler thread
    // Handler is responsible for:
    // 1. Allocating client_data
    // 2. Calling tcp_server_add_client() to register
    // 3. Spawning additional worker threads via tcp_server_spawn_thread() if needed
    // 4. Processing client requests
    // 5. Calling tcp_server_remove_client() on disconnect
    // 6. Closing socket and freeing ctx
    asciichat_thread_t thread;
    if (asciichat_thread_create(&thread, server->config.client_handler, ctx) != 0) {
      log_error("Failed to create client handler thread for %s", client_ip);
      SAFE_FREE(ctx);
      socket_close(client_socket);
      continue;
    }
 
    // Thread is detached (handler is responsible for cleanup)
    (void)thread; // Suppress unused warning
  }
 
  log_info("TCP server accept loop exited");
  return ASCIICHAT_OK;
}

References tcp_server_config_t::accept_timeout_sec, tcp_client_context_t::addr, tcp_client_context_t::addr_len, ASCIICHAT_OK, asciichat_thread_create(), tcp_server_config_t::client_handler, tcp_client_context_t::client_socket, tcp_server::config, EINTR, ERROR_INVALID_PARAM, format_ip_address(), INVALID_SOCKET_VALUE, tcp_server::listen_socket, tcp_server::listen_socket6, log_debug, log_error, log_info, log_warn, tcp_server::running, SAFE_FREE, SAFE_MALLOC, SAFE_STRNCPY, SET_ERRNO, socket_close(), socket_fd_isset(), socket_fd_set(), socket_fd_zero(), socket_get_error_string(), socket_get_last_error(), socket_select(), tcp_client_context_t::user_data, and tcp_server_config_t::user_data.

Referenced by acds_server_run(), and server_main().

tcp_server_set_cleanup_callback()

void tcp_server_set_cleanup_callback	(	tcp_server_t *	server,
		tcp_client_cleanup_fn	cleanup_fn
	)

Set client cleanup callback.

Sets the callback function that will be called when a client is removed from the registry. Use this to free any allocated client_data.

Parameters

server	Server structure
cleanup_fn	Cleanup callback (or NULL to disable)

Definition at line 330 of file lib/network/tcp/server.c.

                                                                                             {
  if (!server) {
    return;
  }
  server->cleanup_fn = cleanup_fn;
}

References tcp_server::cleanup_fn.

tcp_server_shutdown()

void tcp_server_shutdown

(

tcp_server_t *

server

)

Shutdown TCP server.

Closes listen sockets and cleans up resources. Does NOT wait for client threads to exit (caller's responsibility).

Parameters

server

Server structure to clean up

Definition at line 273 of file lib/network/tcp/server.c.

                                               {
  if (!server) {
    return;
  }
 
  log_info("Shutting down TCP server...");
 
  // Signal server to stop
  atomic_store(&server->running, false);
 
  // Close listen sockets
  if (server->listen_socket != INVALID_SOCKET_VALUE) {
    log_debug("Closing IPv4 listen socket");
    socket_close(server->listen_socket);
    server->listen_socket = INVALID_SOCKET_VALUE;
  }
 
  if (server->listen_socket6 != INVALID_SOCKET_VALUE) {
    log_debug("Closing IPv6 listen socket");
    socket_close(server->listen_socket6);
    server->listen_socket6 = INVALID_SOCKET_VALUE;
  }
 
  // Clean up client registry
  mutex_lock(&server->clients_mutex);
 
  tcp_client_entry_t *entry, *tmp;
  HASH_ITER(hh, server->clients, entry, tmp) {
    // Call cleanup callback if set
    if (server->cleanup_fn && entry->client_data) {
      server->cleanup_fn(entry->client_data);
    }
 
    // Destroy thread pool (stops all threads and frees resources)
    if (entry->threads) {
      thread_pool_destroy(entry->threads);
      entry->threads = NULL;
    }
 
    HASH_DEL(server->clients, entry);
    SAFE_FREE(entry);
  }
  server->clients = NULL;
 
  mutex_unlock(&server->clients_mutex);
  mutex_destroy(&server->clients_mutex);
 
  // Note: This function does NOT wait for client threads to exit
  // Caller is responsible for thread lifecycle management
 
  log_info("TCP server shutdown complete");
}

References tcp_server::cleanup_fn, tcp_client_entry::client_data, tcp_server::clients, tcp_server::clients_mutex, INVALID_SOCKET_VALUE, tcp_server::listen_socket, tcp_server::listen_socket6, log_debug, log_info, mutex_destroy(), mutex_lock, mutex_unlock, tcp_server::running, SAFE_FREE, socket_close(), thread_pool_destroy(), and tcp_client_entry::threads.

Referenced by acds_server_init(), acds_server_shutdown(), and server_main().

tcp_server_spawn_thread()

asciichat_error_t tcp_server_spawn_thread	(	tcp_server_t *	server,
		socket_t	client_socket,
		void *(*)(void *)	thread_func,
		void *	thread_arg,
		int	stop_id,
		const char *	thread_name
	)

Spawn a worker thread for a client.

Creates and tracks a new worker thread for the specified client. Threads are identified by stop_id for ordered cleanup - lower stop_id values are stopped first when the client disconnects.

Example stop_id ordering:

• stop_id=1: Receive thread (stop first to prevent new data)
• stop_id=2: Render threads (stop after receive)
• stop_id=3: Send thread (stop last after all processing done)

Parameters

server	Server structure
client_socket	Client socket to spawn thread for
thread_func	Thread function to execute
thread_arg	Argument passed to thread function
stop_id	Cleanup order (lower = stop first)
thread_name	Thread name for debugging (max 63 chars)

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 521 of file lib/network/tcp/server.c.

                                                                                                  {
  if (!server || !thread_func) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server or thread_func is NULL");
  }
 
  if (client_socket == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "client_socket is invalid");
  }
 
  // Find client entry
  mutex_lock(&server->clients_mutex);
  tcp_client_entry_t *entry = NULL;
  HASH_FIND(hh, server->clients, &client_socket, sizeof(socket_t), entry);
 
  if (!entry) {
    mutex_unlock(&server->clients_mutex);
    return SET_ERRNO(ERROR_NOT_FOUND, "Client socket=%d not in registry", client_socket);
  }
 
  // Spawn thread in client's thread pool
  asciichat_error_t result = thread_pool_spawn(entry->threads, thread_func, thread_arg, stop_id, thread_name);
 
  mutex_unlock(&server->clients_mutex);
 
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  size_t thread_count = thread_pool_get_count(entry->threads);
  log_debug("Spawned thread '%s' (stop_id=%d) for client socket=%d (total_threads=%zu)",
            thread_name ? thread_name : "unnamed", stop_id, client_socket, thread_count);
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, tcp_server::clients, tcp_server::clients_mutex, ERROR_INVALID_PARAM, ERROR_NOT_FOUND, INVALID_SOCKET_VALUE, log_debug, mutex_lock, mutex_unlock, SET_ERRNO, thread_pool_get_count(), thread_pool_spawn(), and tcp_client_entry::threads.

Referenced by create_client_render_threads().

tcp_server_stop_client_threads()

asciichat_error_t tcp_server_stop_client_threads	(	tcp_server_t *	server,
		socket_t	client_socket
	)

Stop all threads for a client in stop_id order.

Stops all worker threads spawned for the specified client. Threads are stopped in ascending stop_id order (lower values first). Joins each thread to ensure it has fully exited before proceeding.

Parameters

server	Server structure
client_socket	Client socket whose threads to stop

Returns

ASCIICHAT_OK on success, error code on failure

Definition at line 557 of file lib/network/tcp/server.c.

                                                                                               {
  if (!server) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "server is NULL");
  }
 
  if (client_socket == INVALID_SOCKET_VALUE) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "client_socket is invalid");
  }
 
  // Find client entry
  mutex_lock(&server->clients_mutex);
  tcp_client_entry_t *entry = NULL;
  HASH_FIND(hh, server->clients, &client_socket, sizeof(socket_t), entry);
 
  if (!entry) {
    mutex_unlock(&server->clients_mutex);
    return SET_ERRNO(ERROR_NOT_FOUND, "Client socket=%d not in registry", client_socket);
  }
 
  // Stop all threads in client's thread pool (in stop_id order)
  asciichat_error_t result = ASCIICHAT_OK;
  if (entry->threads) {
    result = thread_pool_stop_all(entry->threads);
  }
 
  mutex_unlock(&server->clients_mutex);
 
  log_debug("All threads stopped for client socket=%d", client_socket);
  return result;
}

References ASCIICHAT_OK, tcp_server::clients, tcp_server::clients_mutex, ERROR_INVALID_PARAM, ERROR_NOT_FOUND, INVALID_SOCKET_VALUE, log_debug, mutex_lock, mutex_unlock, SET_ERRNO, thread_pool_stop_all(), and tcp_client_entry::threads.