🔗 Server connection establishment, packet transmission, and state tracking More...

Files
file	server.c
	🌐 Client connection manager: TCP connection, reconnection with exponential backoff, and thread-safe transmission

file	server.h
	ascii-chat Client Server Connection Management Interface

Functions
int	server_connection_init ()
	Initialize the server connection management subsystem.

int	server_connection_establish (const char *address, int port, int reconnect_attempt, bool first_connection, bool has_ever_connected)
	Establish connection to ascii-chat server.

bool	server_connection_is_active ()
	Check if server connection is currently active.

socket_t	server_connection_get_socket ()
	Get current socket file descriptor.

acip_transport_t *	server_connection_get_transport (void)
	Get ACIP transport instance.

void	server_connection_set_transport (acip_transport_t *transport)
	Set ACIP transport instance from connection fallback.

uint32_t	server_connection_get_client_id ()
	Get client ID assigned by server.

const char *	server_connection_get_ip ()
	Get resolved server IP address.

void	server_connection_set_ip (const char *ip)
	Set the server IP address.

void	server_connection_close ()
	Close the server connection gracefully.

void	server_connection_shutdown ()
	Emergency connection shutdown for signal handlers.

void	server_connection_lost ()
	Signal that connection has been lost.

bool	server_connection_is_lost ()
	Check if connection loss has been detected.

void	server_connection_cleanup ()
	Cleanup connection management subsystem.

asciichat_error_t	threaded_send_packet (packet_type_t type, const void *data, size_t len)
	Thread-safe packet transmission.

int	threaded_send_audio_batch_packet (const float *samples, int num_samples, int batch_count)
	Thread-safe batched audio packet transmission.

asciichat_error_t	threaded_send_audio_opus (const uint8_t *opus_data, size_t opus_size, int sample_rate, int frame_duration)
	Thread-safe Opus audio frame transmission.

asciichat_error_t	threaded_send_audio_opus_batch (const uint8_t opus_data, size_t opus_size, const uint16_t frame_sizes, int frame_count)
	Thread-safe Opus audio batch packet transmission.

int	threaded_send_ping_packet (void)
	Thread-safe ping packet transmission.

int	threaded_send_pong_packet (void)
	Thread-safe pong packet transmission.

int	threaded_send_stream_start_packet (uint32_t stream_type)
	Thread-safe stream start packet transmission.

int	threaded_send_terminal_size_with_auto_detect (unsigned short width, unsigned short height)
	Thread-safe terminal size packet transmission with auto-detection.

int	threaded_send_client_join_packet (const char *display_name, uint32_t capabilities)
	Thread-safe client join packet transmission.

int	server_send_packet (packet_type_t type, const void *data, size_t len)
	Send general packet to server.

int	server_send_audio (const float *samples, int num_samples)
	Send audio data to server.

int	server_send_audio_batch (const float *samples, int num_samples, int batch_count)
	Send batched audio data to server.

int	server_send_terminal_capabilities (unsigned short width, unsigned short height)
	Send terminal capabilities to server.

int	server_send_ping ()
	Send ping keepalive packet.

int	server_send_pong ()
	Send pong response packet.

int	server_send_stream_start (uint32_t stream_type)
	Send stream start notification.

int	server_send_stream_stop (uint32_t stream_type)
	Send stream stop notification.

Variables
crypto_handshake_context_t	g_crypto_ctx = {0}
	Per-connection crypto handshake context.

Detailed Description

🔗 Server connection establishment, packet transmission, and state tracking

Connection Management

Overview

The connection management subsystem handles TCP socket creation, connection establishment, cryptographic handshake coordination, and thread-safe packet transmission to the server.

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

Connection State

Global State Variables:

g_sockfd: Socket file descriptor
g_client_id: Server-assigned client ID
g_server_ip: Resolved server IP address
g_connection_active: Atomic boolean for connection status
g_connection_lost: Atomic boolean for connection loss detection
g_send_mutex: Mutex protecting all packet sends

Connection Establishment

Connection Flow

int server_connection_establish(const char *address, int port,
                                int reconnect_attempt, bool first_connection,
                                bool has_ever_connected)
{
  // 1. Create socket
  socket_t sockfd = socket(AF_INET, SOCK_STREAM, 0);
 
  // 2. Resolve address (IPv4/IPv6)
  struct addrinfo *result = resolve_address(address, port);
 
  // 3. Connect with timeout
  if (connect(sockfd, result->ai_addr, result->ai_addrlen) < 0) {
    return CONNECTION_ERROR_GENERIC;
  }
 
  // 4. Perform cryptographic handshake
  crypto_handshake_result_t handshake_result =
    perform_crypto_handshake_client(sockfd, &crypto_ctx, opt_server_key,
                                    server_ip, opt_client_key);
 
  if (handshake_result != HANDSHAKE_SUCCESS &&
      handshake_result != HANDSHAKE_WARNING_NO_CLIENT_AUTH) {
    socket_close(sockfd);
    return map_handshake_error(handshake_result);
  }
 
  // 5. Send client capabilities
  send_client_capabilities();
 
  // 6. Update global state
  g_sockfd = sockfd;
  atomic_store(&g_connection_active, true);
  atomic_store(&g_connection_lost, false);
 
  return CONNECTION_SUCCESS;
}

Connection Error Codes

Error Types:

CONNECTION_SUCCESS (0): Connection established successfully
CONNECTION_WARNING_NO_CLIENT_AUTH (1): Connected but server not verifying client
CONNECTION_ERROR_GENERIC (-1): Network error (allow retry)
CONNECTION_ERROR_AUTH_FAILED (-2): Client authentication failed (no retry)
CONNECTION_ERROR_HOST_KEY_FAILED (-3): Server host key verification failed (no retry)

Packet Transmission

Thread-Safe Packet Send

int send_packet_to_server(packet_type_t type, const void *data, size_t data_len,
                         uint32_t client_id)
{
  // Thread-safe send with global mutex
  mutex_lock(&g_send_mutex);
 
  // Check connection status
  if (!server_connection_is_active()) {
    mutex_unlock(&g_send_mutex);
    return -1;
  }
 
  // Send encrypted packet
  int result = send_packet(g_sockfd, &crypto_ctx, type, data, data_len, client_id);
 
  mutex_unlock(&g_send_mutex);
 
  // Detect connection loss on send error
  if (result < 0) {
    server_connection_lost();
  }
 
  return result;
}

Thread Safety:

ALL packet sends MUST go through send_packet_to_server()
Global g_send_mutex prevents interleaved packets
Socket FD checked under mutex protection
Connection loss detected atomically

Connection Loss Detection

Loss Detection Triggers

Connection loss detected by:

Socket write error during send_packet_to_server()
Socket read error during receive_packet() in protocol thread
Keepalive timeout (no pong for 30 seconds)
Decryption failure (corrupted stream)

Loss Handling

void server_connection_lost(void)
{
  // Atomic compare-exchange ensures only first detection triggers action
  bool expected = true;
  if (atomic_compare_exchange_strong(&g_connection_active, &expected, false)) {
    // First thread to detect loss
    atomic_store(&g_connection_lost, true);
    log_warn("Connection lost detected");
  }
}

Connection Cleanup

Graceful Close

void server_connection_close(void)
{
  if (g_sockfd != INVALID_SOCKET_VALUE) {
    socket_shutdown(g_sockfd, SHUT_RDWR);  // Signal shutdown
    socket_close(g_sockfd);                 // Close socket
    g_sockfd = INVALID_SOCKET_VALUE;
  }
 
  atomic_store(&g_connection_active, false);
  g_client_id = 0;
}

Emergency Shutdown

void server_connection_shutdown(void)
{
  // Signal-safe emergency shutdown
  if (g_sockfd != INVALID_SOCKET_VALUE) {
    socket_close(g_sockfd);  // Immediate close (no shutdown)
    g_sockfd = INVALID_SOCKET_VALUE;
  }
}

Best Practices

DO:

Always use send_packet_to_server() for packet transmission
Check server_connection_is_active() before operations
Use atomic operations for connection state flags
Wait for thread exit before reconnection

DON'T:

Don't send packets without g_send_mutex
Don't close socket while threads may be using it
Don't ignore return values from send operations
Don't modify g_sockfd directly (use provided functions)

See also: src/client/server.c; src/client/server.h; Client Overview

Function Documentation

◆ server_connection_cleanup()

void server_connection_cleanup ( )

#include <server.c>

Cleanup connection management subsystem.

Closes any active connection and destroys synchronization objects. Called during client shutdown.

Definition at line 858 of file src/client/server.c.

                                 {
  log_set_terminal_output(true);
  server_connection_close();
  mutex_destroy(&g_send_mutex);
}

References log_set_terminal_output(), mutex_destroy(), and server_connection_close().

◆ server_connection_close()

void server_connection_close ( )

#include <server.c>

Close the server connection gracefully.

Close server connection gracefully.

Marks connection as inactive and closes the socket. This function is safe to call multiple times and from multiple threads.

Definition at line 765 of file src/client/server.c.

                               {
  atomic_store(&g_connection_active, false);
 
  // Destroy ACIP transport before closing socket
  if (g_client_transport) {
    acip_transport_destroy(g_client_transport);
    g_client_transport = NULL;
  }
 
  if (g_sockfd != INVALID_SOCKET_VALUE) {
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
  }
 
  g_my_client_id = 0;
 
  // Cleanup crypto context if encryption was enabled
  if (g_encryption_enabled) {
    crypto_handshake_cleanup(&g_crypto_ctx);
    g_encryption_enabled = false;
  }
 
  // Turn ON terminal logging when connection is closed
  log_set_terminal_output(true);
}

References acip_transport_destroy(), close_socket, crypto_handshake_cleanup(), g_crypto_ctx, INVALID_SOCKET_VALUE, and log_set_terminal_output().

Referenced by client_main(), and server_connection_cleanup().

◆ server_connection_establish()

int server_connection_establish	(	const char *	address,
		int	port,
		int	reconnect_attempt,
		bool	first_connection,
		bool	has_ever_connected
	)

#include <server.c>

Establish connection to ascii-chat server.

Attempts to connect to the specified server with full capability negotiation. Implements reconnection logic with exponential backoff for failed attempts. On successful connection, performs initial handshake including terminal capabilities and client join protocol.

Parameters

address	Server IP address or hostname
port	Server port number
reconnect_attempt	Current reconnection attempt number (0 for first)
first_connection	True if this is the initial connection attempt
has_ever_connected	True if a connection was ever successfully established

Returns: 0 on success, negative on error

Parameters

address	Server IP address or hostname
port	Server port number
reconnect_attempt	Current reconnection attempt (0 for first)
first_connection	True if this is the initial connection
has_ever_connected	True if a connection was ever successfully established

Returns: 0 on success, negative on error

Definition at line 322 of file src/client/server.c.

                                                         {
  (void)first_connection; // Currently unused
  if (!address || port <= 0) {
    log_error("Invalid address or port parameters");
    return -1;
  }
 
  // Close any existing connection
  if (g_sockfd != INVALID_SOCKET_VALUE) {
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
  }
 
  // Apply reconnection delay if this is a retry
  if (reconnect_attempt > 0) {
    unsigned int delay_us = get_reconnect_delay(reconnect_attempt);
    // Reconnection attempt logged only to file
    platform_sleep_usec(delay_us);
 
    // Check if user requested exit during reconnection delay
    if (should_exit()) {
      log_debug("Exit requested during reconnection delay");
      return -1;
    }
  } else {
    // Initial connection logged only to file
  }
 
  // Resolve server address using getaddrinfo() for IPv4/IPv6 support
  // Special handling for localhost: ensure we try both IPv6 (::1) and IPv4 (127.0.0.1)
  // Many systems only map "localhost" to 127.0.0.1 in /etc/hosts
  bool is_localhost =
      (strcmp(address, "localhost") == 0 || strcmp(address, "127.0.0.1") == 0 || strcmp(address, "::1") == 0);
 
  struct addrinfo hints, *res = NULL, *addr_iter;
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC; // Allow IPv4 or IPv6
  hints.ai_socktype = SOCK_STREAM;
  if (is_localhost) {
    hints.ai_flags = AI_NUMERICSERV; // Optimize for localhost
  }
 
  char port_str[16];
  SAFE_SNPRINTF(port_str, sizeof(port_str), "%d", port);
 
  // For localhost, try IPv6 loopback (::1) first, then fall back to DNS resolution
  if (is_localhost) {
    log_debug("Localhost detected - trying IPv6 loopback [::1]:%s first...", port_str);
    hints.ai_family = AF_INET6;
    hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
 
    int ipv6_result = getaddrinfo("::1", port_str, &hints, &res);
    if (ipv6_result == 0 && res != NULL) {
      // Try IPv6 loopback connection
      g_sockfd = socket_create(res->ai_family, res->ai_socktype, res->ai_protocol);
      if (g_sockfd != INVALID_SOCKET_VALUE) {
        log_info("Trying IPv6 loopback connection to [::1]:%s...", port_str);
        if (connect_with_timeout(g_sockfd, res->ai_addr, res->ai_addrlen, CONNECT_TIMEOUT)) {
          log_debug("Connection successful using IPv6 loopback");
          SAFE_STRNCPY(g_server_ip, "::1", sizeof(g_server_ip));
          freeaddrinfo(res);
          res = NULL; // Prevent double-free at connection_success label
          goto connection_success;
        }
        if (socket_get_error(g_sockfd) != 0) {
          log_debug("NETWORK_ERROR: %d", (int)socket_get_error(g_sockfd));
        } else {
          // log_debug("IPv6 loopback connection failed: %s", network_error_string());
        }
        close_socket(g_sockfd);
        g_sockfd = INVALID_SOCKET_VALUE;
      }
      freeaddrinfo(res);
      res = NULL;
    }
 
    // Check if user requested exit (Ctrl-C) before trying IPv4
    if (should_exit()) {
      log_debug("Exit requested during connection attempt");
      return -1;
    }
 
    // IPv6 failed, try IPv4 loopback (127.0.0.1)
    log_debug("IPv6 failed, trying IPv4 loopback 127.0.0.1:%s...", port_str);
    hints.ai_family = AF_INET;
 
    int ipv4_result = getaddrinfo("127.0.0.1", port_str, &hints, &res);
    if (ipv4_result == 0 && res != NULL) {
      g_sockfd = socket_create(res->ai_family, res->ai_socktype, res->ai_protocol);
      if (g_sockfd != INVALID_SOCKET_VALUE) {
        log_info("Trying IPv4 loopback connection to 127.0.0.1:%s...", port_str);
        if (connect_with_timeout(g_sockfd, res->ai_addr, res->ai_addrlen, CONNECT_TIMEOUT)) {
          log_debug("Connection successful using IPv4 loopback");
          SAFE_STRNCPY(g_server_ip, "127.0.0.1", sizeof(g_server_ip));
          freeaddrinfo(res);
          res = NULL; // Prevent double-free at connection_success label
          goto connection_success;
        }
        if (socket_get_error(g_sockfd) != 0) {
          log_debug("NETWORK_ERROR: %d", (int)socket_get_error(g_sockfd));
        } else {
          // log_debug("IPv4 loopback connection failed: %s", network_error_string());
        }
        close_socket(g_sockfd);
        g_sockfd = INVALID_SOCKET_VALUE;
      }
      freeaddrinfo(res);
      res = NULL;
    }
 
    // Both IPv6 and IPv4 loopback failed for localhost
    log_warn("Could not connect to localhost using either IPv6 or IPv4 loopback");
    return -1;
  }
 
  // For non-localhost addresses, use standard resolution
  log_debug("Resolving server address '%s' port %s...", address, port_str);
  hints.ai_family = AF_UNSPEC;
  hints.ai_flags = 0;
  int getaddr_result = getaddrinfo(address, port_str, &hints, &res);
  if (getaddr_result != 0) {
    log_error("Failed to resolve server address '%s': %s", address, gai_strerror(getaddr_result));
    return -1;
  }
 
  // Try each address returned by getaddrinfo() until one succeeds
  // Prefer IPv6 over IPv4: try IPv6 addresses first, then fall back to IPv4
  for (int address_family = AF_INET6; address_family >= AF_INET; address_family -= (AF_INET6 - AF_INET)) {
    for (addr_iter = res; addr_iter != NULL; addr_iter = addr_iter->ai_next) {
      // Skip addresses that don't match current pass (IPv6 first, then IPv4)
      if (addr_iter->ai_family != address_family) {
        continue;
      }
 
      // Create socket with appropriate address family
      g_sockfd = socket_create(addr_iter->ai_family, addr_iter->ai_socktype, addr_iter->ai_protocol);
      if (g_sockfd == INVALID_SOCKET_VALUE) {
        log_debug("Could not create socket for address family %d: %s", addr_iter->ai_family, network_error_string());
        continue; // Try next address
      }
 
      // Log which address family we're trying
      if (addr_iter->ai_family == AF_INET) {
        log_debug("Trying IPv4 connection...");
      } else if (addr_iter->ai_family == AF_INET6) {
        log_debug("Trying IPv6 connection...");
      }
 
      // Attempt connection with timeout
      if (connect_with_timeout(g_sockfd, addr_iter->ai_addr, addr_iter->ai_addrlen, CONNECT_TIMEOUT)) {
        // Connection successful!
        log_debug("Connection successful using %s", addr_iter->ai_family == AF_INET    ? "IPv4"
                                                    : addr_iter->ai_family == AF_INET6 ? "IPv6"
                                                                                       : "unknown protocol");
 
        // Extract server IP address for known_hosts
        if (format_ip_address(addr_iter->ai_family, addr_iter->ai_addr, g_server_ip, sizeof(g_server_ip)) ==
            ASCIICHAT_OK) {
          log_debug("Resolved server IP: %s", g_server_ip);
        } else {
          log_warn("Failed to format server IP address");
        }
 
        goto connection_success; // Break out of both loops
      }
 
      // Connection failed - close socket and try next address
      if (socket_get_error(g_sockfd) != 0) {
        log_debug("NETWORK_ERROR: %d", (int)socket_get_error(g_sockfd));
      } else {
        // log_debug("Connection failed: %s", network_error_string());
      }
      close_socket(g_sockfd);
      g_sockfd = INVALID_SOCKET_VALUE;
    }
  }
 
connection_success:
 
  if (res) {
    freeaddrinfo(res);
  }
 
  // If we exhausted all addresses without success, fail
  if (g_sockfd == INVALID_SOCKET_VALUE) {
    log_warn("Could not connect to server %s:%d (tried all addresses)", address, port);
    return -1;
  }
 
  // Connection successful - extract local port for client ID
  struct sockaddr_storage local_addr = {0};
  socklen_t addr_len = sizeof(local_addr);
  if (getsockname(g_sockfd, (struct sockaddr *)&local_addr, &addr_len) == -1) {
    log_error("Failed to get local socket address: %s", network_error_string());
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
    return -1;
  }
 
  // Extract port from either IPv4 or IPv6 address
  int local_port = 0;
  if (((struct sockaddr *)&local_addr)->sa_family == AF_INET) {
    local_port = NET_TO_HOST_U16(((struct sockaddr_in *)&local_addr)->sin_port);
  } else if (((struct sockaddr *)&local_addr)->sa_family == AF_INET6) {
    local_port = NET_TO_HOST_U16(((struct sockaddr_in6 *)&local_addr)->sin6_port);
  }
  g_my_client_id = (uint32_t)local_port;
 
  // Mark connection as active immediately after successful socket connection
  atomic_store(&g_connection_active, true);
  atomic_store(&g_connection_lost, false);
  atomic_store(&g_should_reconnect, false);
 
  // Initialize crypto BEFORE starting protocol handshake
  // Note: server IP is already set above in the connection loop
  log_debug("CLIENT_CONNECT: Calling client_crypto_init()");
  if (client_crypto_init() != 0) {
    log_error("Failed to initialize crypto (password required or incorrect)");
    log_debug("CLIENT_CONNECT: client_crypto_init() failed");
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
    return CONNECTION_ERROR_AUTH_FAILED; // SSH key password was wrong - no retry
  }
 
  // Perform crypto handshake if encryption is enabled
  log_debug("CLIENT_CONNECT: Calling client_crypto_handshake()");
  int handshake_result = client_crypto_handshake(g_sockfd);
  if (handshake_result != 0) {
    log_error("Crypto handshake failed");
    log_debug("CLIENT_CONNECT: client_crypto_handshake() failed with code %d", handshake_result);
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
    FATAL(ERROR_CRYPTO_HANDSHAKE,
          "Crypto handshake failed with server - this usually indicates a protocol mismatch or network issue");
  }
  log_debug("CLIENT_CONNECT: client_crypto_handshake() succeeded");
 
  // Create ACIP transport for protocol-agnostic packet sending
  // The transport wraps the socket with encryption context from the handshake
  const crypto_context_t *crypto_ctx = crypto_client_is_ready() ? crypto_client_get_context() : NULL;
  g_client_transport = acip_tcp_transport_create(g_sockfd, (crypto_context_t *)crypto_ctx);
  if (!g_client_transport) {
    log_error("Failed to create ACIP transport");
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
    return -1;
  }
  log_debug("CLIENT_CONNECT: Created ACIP transport with crypto context");
 
  // Turn OFF terminal logging when successfully connected to server
  // First connection - we'll disable logging after main.c shows the "Connected successfully" message
  if (!GET_OPTION(snapshot_mode)) {
    log_debug("Connected to server - terminal logging will be disabled after initial setup");
  } else {
    log_debug("Connected to server - terminal logging kept enabled for snapshot mode");
  }
 
  // Configure socket options for optimal performance
  if (socket_set_keepalive(g_sockfd, true) < 0) {
    log_warn("Failed to set socket keepalive: %s", network_error_string());
  }
 
  // Configure socket buffers and TCP_NODELAY for optimal performance
  asciichat_error_t sock_config_result = socket_configure_buffers(g_sockfd);
  if (sock_config_result != ASCIICHAT_OK) {
    log_warn("Failed to configure socket: %s", network_error_string());
  }
 
  // Send initial terminal capabilities to server (this may generate debug logs)
  int result = threaded_send_terminal_size_with_auto_detect(GET_OPTION(width), GET_OPTION(height));
  if (result < 0) {
    log_error("Failed to send initial capabilities to server: %s", network_error_string());
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
    return -1;
  }
 
  // Now disable terminal logging after capabilities are sent (for reconnections)
  if (!GET_OPTION(snapshot_mode) && has_ever_connected) {
    log_set_terminal_output(false);
    log_debug("Reconnected to server - terminal logging disabled to prevent interference with ASCII display");
  }
 
  // Send client join packet for multi-user support
  uint32_t my_capabilities = CLIENT_CAP_VIDEO; // Basic video capability
  log_info("GET_OPTION(audio_enabled) = %d (sending CLIENT_JOIN)", GET_OPTION(audio_enabled));
  if (GET_OPTION(audio_enabled)) {
    log_info("Adding CLIENT_CAP_AUDIO to capabilities");
    my_capabilities |= CLIENT_CAP_AUDIO;
  }
  if (GET_OPTION(color_mode) != COLOR_MODE_NONE) {
    my_capabilities |= CLIENT_CAP_COLOR;
  }
  if (GET_OPTION(stretch)) {
    my_capabilities |= CLIENT_CAP_STRETCH;
  }
 
  // Generate display name from username + PID
  const char *display_name = platform_get_username();
 
  char my_display_name[MAX_DISPLAY_NAME_LEN];
  int pid = getpid();
  SAFE_SNPRINTF(my_display_name, sizeof(my_display_name), "%s-%d", display_name, pid);
 
  if (threaded_send_client_join_packet(my_display_name, my_capabilities) < 0) {
    log_error("Failed to send client join packet: %s", network_error_string());
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
    return -1;
  }
 
  // Connection already marked as active after socket creation
 
  return 0;
}

References acip_tcp_transport_create(), ASCIICHAT_OK, CLIENT_CAP_AUDIO, CLIENT_CAP_COLOR, CLIENT_CAP_STRETCH, CLIENT_CAP_VIDEO, client_crypto_handshake(), client_crypto_init(), close_socket, COLOR_MODE_NONE, CONNECT_TIMEOUT, connect_with_timeout(), CONNECTION_ERROR_AUTH_FAILED, crypto_client_get_context(), crypto_client_is_ready(), ERROR_CRYPTO_HANDSHAKE, FATAL, format_ip_address(), GET_OPTION, INVALID_SOCKET_VALUE, log_debug, log_error, log_info, log_set_terminal_output(), log_warn, MAX_DISPLAY_NAME_LEN, NET_TO_HOST_U16, network_error_string(), platform_get_username(), platform_sleep_usec(), SAFE_SNPRINTF, SAFE_STRNCPY, should_exit(), socket_configure_buffers(), socket_create(), socket_get_error(), socket_set_keepalive(), threaded_send_client_join_packet(), and threaded_send_terminal_size_with_auto_detect().

◆ server_connection_get_client_id()

uint32_t server_connection_get_client_id ( )

#include <server.c>

Get client ID assigned by server.

Returns: Client ID (based on local port) or 0 if not connected; Client ID or 0 if not connected

Definition at line 719 of file src/client/server.c.

                                           {
  return g_my_client_id;
}

◆ server_connection_get_ip()

const char * server_connection_get_ip ( )

#include <server.c>

Get resolved server IP address.

Returns the server's IP address that was resolved during connection establishment. Used for known_hosts verification and logging.

Returns: Server IP address string (IPv4 or IPv6), or empty string if not connected; Server IP address string (IPv4 or IPv6)

Definition at line 733 of file src/client/server.c.

                                       {
  return g_server_ip;
}

Referenced by client_crypto_init().

◆ server_connection_get_socket()

socket_t server_connection_get_socket ( )

#include <server.c>

Get current socket file descriptor.

Returns: Socket file descriptor or INVALID_SOCKET_VALUE if disconnected; Socket FD or INVALID_SOCKET_VALUE if disconnected

Definition at line 657 of file src/client/server.c.

                                        {
  return g_sockfd;
}

Referenced by crypto_client_initiate_rekey(), crypto_client_send_rekey_complete(), crypto_client_send_rekey_response(), threaded_send_audio_batch_packet(), threaded_send_client_join_packet(), threaded_send_stream_start_packet(), and threaded_send_terminal_size_with_auto_detect().

◆ server_connection_get_transport()

struct acip_transport * server_connection_get_transport ( void )

#include <server.c>

Get ACIP transport instance.

Returns: Transport instance or NULL if not connected

Definition at line 668 of file src/client/server.c.

                                                        {
  return g_client_transport;
}

◆ server_connection_init()

int server_connection_init ( )

#include <server.c>

Initialize the server connection management subsystem.

Initialize server connection management subsystem.

Sets up the send mutex and initializes connection state variables. Must be called once during client startup before any connection attempts.

Returns: 0 on success, non-zero on failure; 0 on success, negative on error

Definition at line 287 of file src/client/server.c.

                             {
  // Initialize mutex for thread-safe packet sending
  if (mutex_init(&g_send_mutex) != 0) {
    log_error("Failed to initialize send mutex");
    return -1;
  }
 
  // Initialize connection state
  g_sockfd = INVALID_SOCKET_VALUE;
  g_client_transport = NULL;
  atomic_store(&g_connection_active, false);
  atomic_store(&g_connection_lost, false);
  atomic_store(&g_should_reconnect, false);
  g_my_client_id = 0;
 
  return 0;
}

References INVALID_SOCKET_VALUE, log_error, and mutex_init().

◆ server_connection_is_active()

bool server_connection_is_active ( )

#include <server.c>

Check if server connection is currently active.

Returns: true if connection is active, false otherwise

Definition at line 646 of file src/client/server.c.

                                   {
  return atomic_load(&g_connection_active) && (g_sockfd != INVALID_SOCKET_VALUE);
}

References INVALID_SOCKET_VALUE.

Referenced by __attribute__(), and client_main().

◆ server_connection_is_lost()

bool server_connection_is_lost ( )

#include <server.c>

Check if connection loss has been detected.

Check if connection loss was detected.

Returns: true if connection loss was flagged, false otherwise; true if connection lost, false otherwise

Definition at line 846 of file src/client/server.c.

                                 {
  return atomic_load(&g_connection_lost);
}

Referenced by __attribute__(), and protocol_connection_lost().

◆ server_connection_lost()

void server_connection_lost ( )

#include <server.c>

Signal that connection has been lost.

Called by other modules (typically protocol handlers) when they detect connection failure. Triggers reconnection logic in main loop.

Definition at line 830 of file src/client/server.c.

                              {
  atomic_store(&g_connection_lost, true);
  atomic_store(&g_connection_active, false);
 
  // Turn ON terminal logging when connection is lost
  log_set_terminal_output(true);
  display_full_reset();
}

References display_full_reset(), and log_set_terminal_output().

Referenced by __attribute__(), threaded_send_audio_batch_packet(), threaded_send_audio_opus(), threaded_send_audio_opus_batch(), and threaded_send_packet().

◆ server_connection_set_ip()

void server_connection_set_ip ( const char * ip )

#include <server.c>

Set the server IP address.

Updates the global server IP address. Used by new connection code paths that don't use the legacy server_connect() function.

Parameters

ip	Server IP address string
ip	Server IP address string

Definition at line 747 of file src/client/server.c.

                                              {
  if (ip) {
    SAFE_STRNCPY(g_server_ip, ip, sizeof(g_server_ip));
    log_debug("Server IP set to: %s", g_server_ip);
  } else {
    g_server_ip[0] = '\0';
    log_debug("Server IP cleared");
  }
}

References log_debug, and SAFE_STRNCPY.

◆ server_connection_set_transport()

void server_connection_set_transport ( acip_transport_t * transport )

#include <server.c>

Set ACIP transport instance from connection fallback.

Used to integrate the transport from the 3-stage connection fallback orchestrator (TCP → STUN → TURN) into the server connection management layer.

Parameters

transport	Transport instance created by connection_attempt_with_fallback()
transport	Transport instance created by connection_attempt_with_fallback()

Used to integrate the transport from the 3-stage connection fallback orchestrator (TCP → STUN → TURN) into the server connection management layer.

Definition at line 682 of file src/client/server.c.

                                                                  {
  log_debug("server_connection_set_transport() called with transport=%p", (void *)transport);
 
  // Clean up any existing transport
  if (g_client_transport) {
    log_warn("Replacing existing transport with new fallback transport");
    acip_transport_destroy(g_client_transport);
  }
 
  log_debug("Setting g_client_transport to %p", (void *)transport);
  g_client_transport = transport;
 
  // Mark connection as active when transport is set
  if (transport) {
    log_debug("Transport is non-NULL, extracting socket...");
    // Extract socket from transport for backward compatibility with socket-based checks
    g_sockfd = acip_transport_get_socket(transport);
    log_debug("Socket extracted: %d", (int)g_sockfd);
 
    atomic_store(&g_connection_active, true);
    log_debug("Server connection transport set and marked active (sockfd=%d)", (int)g_sockfd);
  } else {
    g_sockfd = INVALID_SOCKET_VALUE;
    atomic_store(&g_connection_active, false);
    log_debug("Server connection transport cleared and marked inactive");
  }
 
  log_debug("server_connection_set_transport() completed");
}

References acip_transport_destroy(), INVALID_SOCKET_VALUE, log_debug, and log_warn.

Referenced by client_main().

◆ server_connection_shutdown()

void server_connection_shutdown ( )

#include <server.c>

Emergency connection shutdown for signal handlers.

Emergency shutdown for signal handlers.

Performs immediate connection shutdown without waiting for graceful close procedures. Uses socket shutdown to interrupt any blocking recv() operations in other threads.

Definition at line 800 of file src/client/server.c.

                                  {
  // NOTE: This function may be called from:
  //   - Signal handlers on Unix (async-signal-safe context)
  //   - SetConsoleCtrlHandler callback thread on Windows (separate thread context)
  // Only use atomic operations and simple system calls - NO mutex locks, NO malloc, NO logging.
 
  atomic_store(&g_connection_active, false);
  atomic_store(&g_connection_lost, true);
 
  if (g_sockfd != INVALID_SOCKET_VALUE) {
    // Only shutdown() the socket to interrupt blocking recv()/send() operations.
    // Do NOT close() here - on Windows, closing the socket while another thread
    // is using it is undefined behavior and can cause STATUS_STACK_BUFFER_OVERRUN.
    // The actual socket close happens in server_connection_close() which is called
    // from the main thread after worker threads have been joined.
    socket_shutdown(g_sockfd, SHUT_RDWR);
  }
 
  // DO NOT call log_set_terminal_output() here - it uses mutex which is NOT async-signal-safe.
  // The normal cleanup path in shutdown_client() will handle logging state.
}

References INVALID_SOCKET_VALUE, and socket_shutdown().

Referenced by protocol_stop_connection().

◆ server_send_audio()

int server_send_audio	(	const float *	samples,
		int	num_samples
	)

#include <server.h>

Send audio data to server.

Parameters

samples	Audio sample buffer
num_samples	Number of samples

Returns: 0 on success, negative on error

◆ server_send_audio_batch()

int server_send_audio_batch	(	const float *	samples,
		int	num_samples,
		int	batch_count
	)

#include <server.h>

Send batched audio data to server.

Parameters

samples	Batched audio samples
num_samples	Total sample count
batch_count	Number of packets in batch

Returns: 0 on success, negative on error

◆ server_send_packet()

int server_send_packet	(	packet_type_t	type,
		const void *	data,
		size_t	len
	)

#include <server.h>

Send general packet to server.

Parameters

type	Packet type identifier
data	Packet payload
len	Payload length

Returns: 0 on success, negative on error

◆ server_send_ping()

int server_send_ping ( )

#include <server.h>

Send ping keepalive packet.

Returns: 0 on success, negative on error

◆ server_send_pong()

int server_send_pong ( )

#include <server.h>

Send pong response packet.

Returns: 0 on success, negative on error

◆ server_send_stream_start()

int server_send_stream_start ( uint32_t stream_type )

#include <server.h>

Send stream start notification.

Parameters

stream_type Type of stream (audio/video)

Returns: 0 on success, negative on error

◆ server_send_stream_stop()

int server_send_stream_stop ( uint32_t stream_type )

#include <server.h>

Send stream stop notification.

Parameters

stream_type Type of stream (audio/video)

Returns: 0 on success, negative on error

◆ server_send_terminal_capabilities()

int server_send_terminal_capabilities	(	unsigned short	width,
		unsigned short	height
	)

#include <server.h>

Send terminal capabilities to server.

Parameters

width	Terminal width in characters
height	Terminal height in characters

Returns: 0 on success, negative on error

◆ threaded_send_audio_batch_packet()

int threaded_send_audio_batch_packet	(	const float *	samples,
		int	num_samples,
		int	batch_count
	)

#include <server.c>

Thread-safe batched audio packet transmission.

Sends a batched audio packet to the server with proper mutex protection and connection state checking. Automatically handles encryption if crypto is ready.

Parameters

samples	Audio sample buffer containing batched samples
num_samples	Total number of samples in the batch
batch_count	Number of audio chunks in this batch

Returns: 0 on success, negative on error

Parameters

samples	Audio sample buffer containing batched samples
num_samples	Total number of samples in the batch
batch_count	Number of audio chunks in this batch

Returns: 0 on success, negative on error

Definition at line 922 of file src/client/server.c.

                                                                                             {
  mutex_lock(&g_send_mutex);
 
  // Recheck connection status INSIDE the mutex to prevent TOCTOU race
  socket_t sockfd = server_connection_get_socket();
  if (!atomic_load(&g_connection_active) || sockfd == INVALID_SOCKET_VALUE) {
    mutex_unlock(&g_send_mutex);
    return -1;
  }
 
  // Get crypto context if encryption is enabled
  const crypto_context_t *crypto_ctx = crypto_client_is_ready() ? crypto_client_get_context() : NULL;
  int result = send_audio_batch_packet(sockfd, samples, num_samples, batch_count, (crypto_context_t *)crypto_ctx);
 
  mutex_unlock(&g_send_mutex);
 
  // If send failed due to network error, signal connection loss
  if (result < 0) {
    server_connection_lost();
  }
 
  return result;
}

References crypto_client_get_context(), crypto_client_is_ready(), INVALID_SOCKET_VALUE, mutex_lock, mutex_unlock, send_audio_batch_packet(), server_connection_get_socket(), and server_connection_lost().

◆ threaded_send_audio_opus()

asciichat_error_t threaded_send_audio_opus	(	const uint8_t *	opus_data,
		size_t	opus_size,
		int	sample_rate,
		int	frame_duration
	)

#include <server.c>

Thread-safe Opus audio frame transmission.

Sends a single Opus-encoded audio frame to the server with proper synchronization and encryption support.

Parameters

opus_data	Opus-encoded audio data
opus_size	Size of encoded frame
sample_rate	Sample rate in Hz
frame_duration	Frame duration in milliseconds

Returns: 0 on success, negative on error

Sends a single Opus-encoded audio frame to the server with proper synchronization and encryption support.

Parameters

opus_data	Opus-encoded audio data
opus_size	Size of encoded frame
sample_rate	Sample rate in Hz
frame_duration	Frame duration in milliseconds

Returns: ASCIICHAT_OK on success, error code on failure

Definition at line 960 of file src/client/server.c.

                                                               {
  mutex_lock(&g_send_mutex);
 
  // Recheck connection status and transport INSIDE the mutex to prevent TOCTOU race
  if (!atomic_load(&g_connection_active) || !g_client_transport) {
    mutex_unlock(&g_send_mutex);
    return SET_ERRNO(ERROR_NETWORK, "Connection not active or transport unavailable");
  }
 
  // Build Opus packet with header
  size_t header_size = 16; // sample_rate (4), frame_duration (4), reserved (8)
  size_t total_size = header_size + opus_size;
  void *packet_data = buffer_pool_alloc(NULL, total_size);
  if (!packet_data) {
    mutex_unlock(&g_send_mutex);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate buffer for Opus packet: %zu bytes", total_size);
  }
 
  // Write header in network byte order
  uint8_t *buf = (uint8_t *)packet_data;
  uint32_t sr = HOST_TO_NET_U32((uint32_t)sample_rate);
  uint32_t fd = HOST_TO_NET_U32((uint32_t)frame_duration);
  memcpy(buf, &sr, 4);
  memcpy(buf + 4, &fd, 4);
  memset(buf + 8, 0, 8); // Reserved
 
  // Copy Opus data
  memcpy(buf + header_size, opus_data, opus_size);
 
  // Send packet via ACIP transport (handles encryption automatically)
  asciichat_error_t result =
      packet_send_via_transport(g_client_transport, PACKET_TYPE_AUDIO_OPUS, packet_data, total_size);
 
  // Clean up
  buffer_pool_free(NULL, packet_data, total_size);
  mutex_unlock(&g_send_mutex);
 
  // If send failed due to network error, signal connection loss
  if (result != ASCIICHAT_OK) {
    server_connection_lost();
    return result;
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, buffer_pool_alloc(), buffer_pool_free(), ERROR_MEMORY, ERROR_NETWORK, HOST_TO_NET_U32, mutex_lock, mutex_unlock, packet_send_via_transport(), PACKET_TYPE_AUDIO_OPUS, server_connection_lost(), and SET_ERRNO.

◆ threaded_send_audio_opus_batch()

asciichat_error_t threaded_send_audio_opus_batch	(	const uint8_t *	opus_data,
		size_t	opus_size,
		const uint16_t *	frame_sizes,
		int	frame_count
	)

#include <server.c>

Thread-safe Opus audio batch packet transmission.

Sends a batch of Opus-encoded audio frames to the server with proper synchronization and encryption support.

Parameters

opus_data	Opus-encoded audio data (multiple frames concatenated)
opus_size	Total size of Opus data in bytes
frame_sizes	Array of individual frame sizes (variable-length frames)
frame_count	Number of Opus frames in the batch

Returns: 0 on success, negative on error

Sends a batch of Opus-encoded audio frames to the server with proper synchronization and encryption support.

Parameters

opus_data	Opus-encoded audio data (multiple frames concatenated)
opus_size	Total size of Opus data in bytes
frame_sizes	Array of individual frame sizes (variable-length frames)
frame_count	Number of Opus frames in the batch

Returns: ASCIICHAT_OK on success, error code on failure

Definition at line 1021 of file src/client/server.c.

                                                                                               {
  mutex_lock(&g_send_mutex);
 
  // Recheck connection status and transport INSIDE the mutex to prevent TOCTOU race
  if (!atomic_load(&g_connection_active) || !g_client_transport) {
    mutex_unlock(&g_send_mutex);
    return SET_ERRNO(ERROR_NETWORK, "Connection not active or transport unavailable");
  }
 
  // Opus uses 20ms frames at 48kHz (960 samples = 20ms)
  asciichat_error_t result =
      acip_send_audio_opus_batch(g_client_transport, opus_data, opus_size, frame_sizes, frame_count, 48000, 20);
 
  mutex_unlock(&g_send_mutex);
 
  // If send failed due to network error, signal connection loss
  if (result != ASCIICHAT_OK) {
    server_connection_lost();
    return result;
  }
 
  return ASCIICHAT_OK;
}

References acip_send_audio_opus_batch(), ASCIICHAT_OK, ERROR_NETWORK, mutex_lock, mutex_unlock, server_connection_lost(), and SET_ERRNO.

◆ threaded_send_client_join_packet()

int threaded_send_client_join_packet	(	const char *	display_name,
		uint32_t	capabilities
	)

#include <server.c>

Thread-safe client join packet transmission.

Sends client join packet with display name and capabilities to the server.

Parameters

display_name	Client display name
capabilities	Client capability flags

Returns: 0 on success, negative on error

Parameters

display_name	Client display name
capabilities	Client capability flags

Returns: 0 on success, negative on error

Definition at line 1187 of file src/client/server.c.

                                                                                      {
  socket_t sockfd = server_connection_get_socket();
  if (!atomic_load(&g_connection_active) || sockfd == INVALID_SOCKET_VALUE) {
    return -1;
  }
 
  // Build CLIENT_JOIN packet locally
  client_info_packet_t join_packet;
  SAFE_MEMSET(&join_packet, sizeof(join_packet), 0, sizeof(join_packet));
  join_packet.client_id = HOST_TO_NET_U32(0); // Will be assigned by server
  SAFE_SNPRINTF(join_packet.display_name, MAX_DISPLAY_NAME_LEN, "%s", display_name ? display_name : "Unknown");
  join_packet.capabilities = HOST_TO_NET_U32(capabilities);
 
  // Use threaded_send_packet() which handles encryption
  int send_result = threaded_send_packet(PACKET_TYPE_CLIENT_JOIN, &join_packet, sizeof(join_packet));
  if (send_result == 0) {
    mutex_lock(&g_send_mutex);
    bool active = atomic_load(&g_connection_active);
    socket_t socket_snapshot = g_sockfd;
    const crypto_context_t *crypto_ctx = crypto_client_is_ready() ? crypto_client_get_context() : NULL;
    if (active && socket_snapshot != INVALID_SOCKET_VALUE) {
      (void)log_network_message(
          socket_snapshot, (const struct crypto_context_t *)crypto_ctx, LOG_INFO, REMOTE_LOG_DIRECTION_CLIENT_TO_SERVER,
          "CLIENT_JOIN sent (display=\"%s\", capabilities=0x%x)", join_packet.display_name, capabilities);
    }
    mutex_unlock(&g_send_mutex);
  }
  return send_result;
}

References client_info_packet_t::capabilities, client_info_packet_t::client_id, crypto_client_get_context(), crypto_client_is_ready(), client_info_packet_t::display_name, HOST_TO_NET_U32, INVALID_SOCKET_VALUE, LOG_INFO, log_network_message(), MAX_DISPLAY_NAME_LEN, mutex_lock, mutex_unlock, PACKET_TYPE_CLIENT_JOIN, REMOTE_LOG_DIRECTION_CLIENT_TO_SERVER, SAFE_MEMSET, SAFE_SNPRINTF, server_connection_get_socket(), and threaded_send_packet().

Referenced by server_connection_establish().

◆ threaded_send_packet()

asciichat_error_t threaded_send_packet	(	packet_type_t	type,
		const void *	data,
		size_t	len
	)

#include <server.c>

Thread-safe packet transmission.

Sends a packet to the server with proper mutex protection and connection state checking. Automatically handles encryption if crypto is ready.

Parameters

type	Packet type identifier
data	Packet payload
len	Payload length

Returns: 0 on success, negative on error

Sends a packet to the server with proper mutex protection and connection state checking. Automatically handles encryption if crypto is ready.

Parameters

type	Packet type identifier
data	Packet payload
len	Payload length

Returns: ASCIICHAT_OK on success, error code on failure

Definition at line 885 of file src/client/server.c.

                                                                                         {
  mutex_lock(&g_send_mutex);
 
  // Recheck connection status and transport INSIDE the mutex to prevent TOCTOU race
  if (!atomic_load(&g_connection_active) || !g_client_transport) {
    mutex_unlock(&g_send_mutex);
    return SET_ERRNO(ERROR_NETWORK, "Connection not active or transport unavailable");
  }
 
  // Use ACIP transport which handles encryption and compression automatically
  asciichat_error_t result = packet_send_via_transport(g_client_transport, type, data, len);
 
  mutex_unlock(&g_send_mutex);
 
  // If send failed due to network error, signal connection loss
  if (result != ASCIICHAT_OK) {
    server_connection_lost();
    return result;
  }
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_NETWORK, mutex_lock, mutex_unlock, packet_send_via_transport(), server_connection_lost(), and SET_ERRNO.

Referenced by threaded_send_client_join_packet(), threaded_send_ping_packet(), threaded_send_pong_packet(), threaded_send_stream_start_packet(), and threaded_send_terminal_size_with_auto_detect().

◆ threaded_send_ping_packet()

int threaded_send_ping_packet ( void )

#include <server.c>

Thread-safe ping packet transmission.

Returns: 0 on success, negative on error

Definition at line 1053 of file src/client/server.c.

                                    {
  // Use threaded_send_packet which handles encryption, mutex locking, and connection state
  return threaded_send_packet(PACKET_TYPE_PING, NULL, 0);
}

References PACKET_TYPE_PING, and threaded_send_packet().

Referenced by __attribute__().

◆ threaded_send_pong_packet()

int threaded_send_pong_packet ( void )

#include <server.c>

Thread-safe pong packet transmission.

Returns: 0 on success, negative on error

Definition at line 1065 of file src/client/server.c.

                                    {
  // Use threaded_send_packet which handles encryption, mutex locking, and connection state
  return threaded_send_packet(PACKET_TYPE_PONG, NULL, 0);
}

References PACKET_TYPE_PONG, and threaded_send_packet().

◆ threaded_send_stream_start_packet()

int threaded_send_stream_start_packet ( uint32_t stream_type )

#include <server.c>

Thread-safe stream start packet transmission.

Parameters

stream_type Type of stream (audio/video)

Returns: 0 on success, negative on error

Definition at line 1078 of file src/client/server.c.

                                                            {
  socket_t sockfd = server_connection_get_socket();
  if (!atomic_load(&g_connection_active) || sockfd == INVALID_SOCKET_VALUE) {
    return -1;
  }
 
  // Build STREAM_START packet locally
  uint32_t type_data = HOST_TO_NET_U32(stream_type);
 
  // Use threaded_send_packet() which handles encryption
  return threaded_send_packet(PACKET_TYPE_STREAM_START, &type_data, sizeof(type_data));
}

References HOST_TO_NET_U32, INVALID_SOCKET_VALUE, PACKET_TYPE_STREAM_START, server_connection_get_socket(), and threaded_send_packet().

Referenced by audio_start_thread(), capture_start_thread(), and protocol_start_connection().

◆ threaded_send_terminal_size_with_auto_detect()

int threaded_send_terminal_size_with_auto_detect	(	unsigned short	width,
		unsigned short	height
	)

#include <server.c>

Thread-safe terminal size packet transmission with auto-detection.

Sends terminal capabilities packet to the server including terminal size, color capabilities, and rendering preferences. Auto-detects terminal capabilities if not explicitly specified.

Parameters

width	Terminal width in characters
height	Terminal height in characters

Returns: 0 on success, negative on error

Parameters

width	Terminal width in characters
height	Terminal height in characters

Returns: 0 on success, negative on error

Definition at line 1104 of file src/client/server.c.

                                                                                              {
 
  socket_t sockfd = server_connection_get_socket();
  if (!atomic_load(&g_connection_active) || sockfd == INVALID_SOCKET_VALUE) {
    return -1;
  }
 
  // Build terminal capabilities packet locally
  // Detect terminal capabilities automatically
  terminal_capabilities_t caps = detect_terminal_capabilities();
 
  // Apply user's color mode override
  caps = apply_color_mode_override(caps);
 
  // Check if detection was reliable, use fallback only for auto-detection
  if (!caps.detection_reliable && GET_OPTION(color_mode) == COLOR_MODE_AUTO) {
    log_warn("Terminal capability detection not reliable, using fallback");
    SAFE_MEMSET(&caps, sizeof(caps), 0, sizeof(caps));
    caps.color_level = TERM_COLOR_NONE;
    caps.color_count = 2;
    caps.capabilities = 0;
    SAFE_STRNCPY(caps.term_type, "unknown", sizeof(caps.term_type));
    SAFE_STRNCPY(caps.colorterm, "", sizeof(caps.colorterm));
    caps.detection_reliable = 0;
  }
 
  // Convert to network packet format with proper byte order
  terminal_capabilities_packet_t net_packet;
  net_packet.capabilities = HOST_TO_NET_U32(caps.capabilities);
  net_packet.color_level = HOST_TO_NET_U32(caps.color_level);
  net_packet.color_count = HOST_TO_NET_U32(caps.color_count);
  net_packet.render_mode = HOST_TO_NET_U32(caps.render_mode);
  net_packet.width = HOST_TO_NET_U16(width);
  net_packet.height = HOST_TO_NET_U16(height);
  net_packet.palette_type = HOST_TO_NET_U32(GET_OPTION(palette_type));
  net_packet.utf8_support = HOST_TO_NET_U32(caps.utf8_support ? 1 : 0);
 
  const options_t *opts = options_get();
  if (GET_OPTION(palette_type) == PALETTE_CUSTOM && GET_OPTION(palette_custom_set)) {
    const char *palette_custom = opts && opts->palette_custom_set ? opts->palette_custom : "";
    SAFE_STRNCPY(net_packet.palette_custom, palette_custom, sizeof(net_packet.palette_custom));
    net_packet.palette_custom[sizeof(net_packet.palette_custom) - 1] = '\0';
  } else {
    SAFE_MEMSET(net_packet.palette_custom, sizeof(net_packet.palette_custom), 0, sizeof(net_packet.palette_custom));
  }
 
  // Set desired FPS
  if (g_max_fps > 0) {
    net_packet.desired_fps = (uint8_t)(g_max_fps > 144 ? 144 : g_max_fps);
  } else {
    net_packet.desired_fps = caps.desired_fps;
  }
 
  if (net_packet.desired_fps == 0) {
    net_packet.desired_fps = DEFAULT_MAX_FPS;
  }
 
  SAFE_STRNCPY(net_packet.term_type, caps.term_type, sizeof(net_packet.term_type));
  net_packet.term_type[sizeof(net_packet.term_type) - 1] = '\0';
 
  SAFE_STRNCPY(net_packet.colorterm, caps.colorterm, sizeof(net_packet.colorterm));
  net_packet.colorterm[sizeof(net_packet.colorterm) - 1] = '\0';
 
  net_packet.detection_reliable = caps.detection_reliable;
  net_packet.utf8_support = GET_OPTION(force_utf8) ? 1 : 0;
 
  SAFE_MEMSET(net_packet.reserved, sizeof(net_packet.reserved), 0, sizeof(net_packet.reserved));
 
  // Use threaded_send_packet() which handles encryption
  return threaded_send_packet(PACKET_TYPE_CLIENT_CAPABILITIES, &net_packet, sizeof(net_packet));
}

Referenced by protocol_start_connection(), and server_connection_establish().

Variable Documentation

◆ g_crypto_ctx

crypto_handshake_context_t g_crypto_ctx = {0}

#include <server.c>

Per-connection crypto handshake context.

Maintains the cryptographic state for the current connection, including key exchange state, encryption keys, and handshake progress.

Note: This is not static because it may be accessed from crypto.c

Definition at line 198 of file src/client/server.c.

198{0};

Referenced by client_crypto_handshake(), client_crypto_init(), crypto_client_cleanup(), crypto_client_decrypt_packet(), crypto_client_encrypt_packet(), crypto_client_get_context(), crypto_client_initiate_rekey(), crypto_client_is_ready(), crypto_client_process_rekey_request(), crypto_client_process_rekey_response(), crypto_client_send_rekey_complete(), crypto_client_send_rekey_response(), crypto_client_should_rekey(), and server_connection_close().

Files

Functions

Variables

Detailed Description

Connection Management

Overview

Connection State

Connection Establishment

Connection Flow

Connection Error Codes

Packet Transmission

Thread-Safe Packet Send

Connection Loss Detection

Loss Detection Triggers

Loss Handling

Connection Cleanup

Graceful Close

Emergency Shutdown

Best Practices

Function Documentation

◆ server_connection_cleanup()

◆ server_connection_close()

◆ server_connection_establish()

◆ server_connection_get_client_id()

◆ server_connection_get_ip()

◆ server_connection_get_socket()

◆ server_connection_get_transport()

◆ server_connection_init()

◆ server_connection_is_active()

◆ server_connection_is_lost()

◆ server_connection_lost()

◆ server_connection_set_ip()

◆ server_connection_set_transport()

◆ server_connection_shutdown()

◆ server_send_audio()

◆ server_send_audio_batch()

◆ server_send_packet()

◆ server_send_ping()

◆ server_send_pong()

◆ server_send_stream_start()

◆ server_send_stream_stop()

◆ server_send_terminal_capabilities()

◆ threaded_send_audio_batch_packet()

◆ threaded_send_audio_opus()

◆ threaded_send_audio_opus_batch()

◆ threaded_send_client_join_packet()

◆ threaded_send_packet()

◆ threaded_send_ping_packet()

◆ threaded_send_pong_packet()

◆ threaded_send_stream_start_packet()

◆ threaded_send_terminal_size_with_auto_detect()

Variable Documentation

◆ g_crypto_ctx