Connection Management

🔗 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.
asciichat_error_t	threaded_send_stream_start_packet (uint32_t stream_type)
	Thread-safe stream start packet transmission.
asciichat_error_t	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.
void	server_connection_set_transport (struct acip_transport *transport)
	Set ACIP transport instance from connection fallback.
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:

1. Socket write error during send_packet_to_server()
2. Socket read error during receive_packet() in protocol thread
3. Keepalive timeout (no pong for 30 seconds)
4. 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 949 of file src/client/server.c.

                                 {
  if (!GET_OPTION(quiet)) {
    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 854 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_destroy(&g_crypto_ctx);
    g_encryption_enabled = false;
  }
 
  // Turn ON terminal logging when connection is closed (unless it was disabled with --quiet)
  if (!GET_OPTION(quiet)) {
    log_set_terminal_output(true);
  }
}

References acip_transport_destroy(), close_socket, crypto_handshake_destroy(), g_crypto_ctx, and log_set_terminal_output().

Referenced by 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 320 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_us(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
  }
 
  // Check for WebSocket URL - handle separately from TCP
  if (url_is_websocket(address)) {
    // WebSocket connection - bypass TCP socket creation
    // Use the original address (URL already contains port if specified)
    const char *ws_url = address;
 
    // Parse for debug logging
    url_parts_t url_parts = {0};
    if (url_parse(address, &url_parts) == ASCIICHAT_OK) {
      log_info("Connecting via WebSocket: %s (scheme=%s, host=%s, port=%d)", ws_url, url_parts.scheme, url_parts.host,
               url_parts.port);
    } else {
      log_info("Connecting via WebSocket: %s", ws_url);
    }
 
    // Initialize crypto if encryption is enabled
    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");
      url_parts_destroy(&url_parts);
      return CONNECTION_ERROR_AUTH_FAILED;
    }
 
    // Get crypto context for transport
    const crypto_context_t *crypto_ctx = crypto_client_is_ready() ? crypto_client_get_context() : NULL;
 
    // Create WebSocket transport (handles connection internally)
    g_client_transport = acip_websocket_client_transport_create(ws_url, (crypto_context_t *)crypto_ctx);
    if (!g_client_transport) {
      log_error("Failed to create WebSocket ACIP transport");
      url_parts_destroy(&url_parts);
      return -1;
    }
    log_debug("CLIENT_CONNECT: Created WebSocket ACIP transport with crypto context");
 
    // Set connection as active
    atomic_store(&g_connection_active, true);
    atomic_store(&g_connection_lost, false);
 
    // Send initial terminal capabilities to server
    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());
      acip_transport_destroy(g_client_transport);
      g_client_transport = NULL;
      url_parts_destroy(&url_parts);
      return -1;
    }
 
    // Disable terminal logging after initial setup (for non-snapshot mode)
    if (!GET_OPTION(snapshot_mode) && has_ever_connected) {
      log_set_terminal_output(false);
    }
 
    // Build capabilities flags
    uint32_t my_capabilities = CLIENT_CAP_VIDEO;
    log_debug("GET_OPTION(audio_enabled) = %d (sending CLIENT_JOIN)", GET_OPTION(audio_enabled));
    if (GET_OPTION(audio_enabled)) {
      log_debug("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());
      acip_transport_destroy(g_client_transport);
      g_client_transport = NULL;
      url_parts_destroy(&url_parts);
      return -1;
    }
 
    log_info("WebSocket connection established successfully");
    url_parts_destroy(&url_parts);
    return 0;
  }
 
  // 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 || is_localhost_ipv4(address) || is_localhost_ipv6(address));
 
  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_debug("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_debug("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;
 
  // Create TCP transport (WebSocket is handled earlier in the function)
  g_client_transport = acip_tcp_transport_create(g_sockfd, (crypto_context_t *)crypto_ctx);
  if (!g_client_transport) {
    log_error("Failed to create TCP ACIP transport");
    close_socket(g_sockfd);
    g_sockfd = INVALID_SOCKET_VALUE;
    return -1;
  }
  log_debug("CLIENT_CONNECT: Created TCP 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_debug("GET_OPTION(audio_enabled) = %d (sending CLIENT_JOIN)", GET_OPTION(audio_enabled));
  if (GET_OPTION(audio_enabled)) {
    log_debug("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(), acip_transport_destroy(), acip_websocket_client_transport_create(), client_crypto_handshake(), client_crypto_init(), close_socket, connect_with_timeout(), CONNECTION_ERROR_AUTH_FAILED, crypto_client_get_context(), crypto_client_is_ready(), format_ip_address(), is_localhost_ipv4(), is_localhost_ipv6(), log_set_terminal_output(), network_error_string(), platform_sleep_us(), should_exit(), socket_configure_buffers(), threaded_send_client_join_packet(), threaded_send_terminal_size_with_auto_detect(), url_is_websocket(), url_parse(), and url_parts_destroy().

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 808 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 822 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 745 of file src/client/server.c.

                                        {
  return g_sockfd;
}

Referenced by crypto_client_initiate_rekey(), crypto_client_send_rekey_complete(), and crypto_client_send_rekey_response().

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 756 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 285 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 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 732 of file src/client/server.c.

                                   {
  // For TCP: check socket validity
  // For WebRTC: socket is INVALID_SOCKET_VALUE but transport exists
  return atomic_load(&g_connection_active) && (g_sockfd != INVALID_SOCKET_VALUE || g_client_transport != NULL);
}

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 937 of file src/client/server.c.

                                 {
  return atomic_load(&g_connection_lost);
}

Referenced by 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 921 of file src/client/server.c.

                              {
  atomic_store(&g_connection_lost, true);
  atomic_store(&g_connection_active, false);
 
  // Don't re-enable terminal logging here - let the splash screen handle it
  // The reconnection splash will capture and display logs properly
  display_full_reset();
}

References display_full_reset().

Referenced by 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 836 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");
  }
}

Referenced by connection_attempt_tcp().

server_connection_set_transport() [1/2]

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()

Definition at line 770 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);
    atomic_store(&g_connection_lost, false); // Reset lost flag for new connection
    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().

server_connection_set_transport() [2/2]

void server_connection_set_transport

(

struct acip_transport *

transport

)

#include <server.h>

Set ACIP transport instance from connection fallback.

Parameters

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.

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 891 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.
}

Referenced by client_main(), and 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 1018 of file src/client/server.c.

                                                                                             {
  // Get transport reference while holding mutex (brief lock)
  mutex_lock(&g_send_mutex);
 
  // Check connection status and get transport reference
  if (!atomic_load(&g_connection_active) || !g_client_transport) {
    mutex_unlock(&g_send_mutex);
    return -1;
  }
 
  // Get transport reference - transport has its own internal synchronization
  acip_transport_t *transport = g_client_transport;
  mutex_unlock(&g_send_mutex);
 
  // Network I/O happens OUTSIDE the mutex to prevent deadlock on TCP buffer full
  asciichat_error_t result = acip_send_audio_batch(transport, samples, (uint32_t)num_samples, (uint32_t)batch_count);
 
  // If send failed due to network error, signal connection loss
  if (result != ASCIICHAT_OK) {
    server_connection_lost();
    return -1;
  }
 
  return 0;
}

References acip_send_audio_batch(), 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 1058 of file src/client/server.c.

                                                               {
  // Get transport reference while holding mutex (brief lock)
  mutex_lock(&g_send_mutex);
 
  // Check connection status and get transport reference
  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");
  }
 
  // Get transport reference - transport has its own internal synchronization
  acip_transport_t *transport = g_client_transport;
  mutex_unlock(&g_send_mutex);
 
  // Build Opus packet with header (outside mutex - no blocking I/O yet)
  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) {
    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);
 
  // Network I/O happens OUTSIDE the mutex to prevent deadlock on TCP buffer full
  asciichat_error_t result =
      packet_send_via_transport(transport, PACKET_TYPE_AUDIO_OPUS_BATCH, packet_data, total_size, 0);
 
  // Clean up
  buffer_pool_free(NULL, packet_data, total_size);
 
  // If send failed due to network error, signal connection loss
  if (result != ASCIICHAT_OK) {
    server_connection_lost();
    return result;
  }
 
  return ASCIICHAT_OK;
}

References buffer_pool_alloc(), buffer_pool_free(), packet_send_via_transport(), and server_connection_lost().

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 1122 of file src/client/server.c.

                                                                                               {
  // Get transport reference while holding mutex (brief lock)
  mutex_lock(&g_send_mutex);
 
  // Check connection status and get transport reference
  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");
  }
 
  // Get transport reference - transport has its own internal synchronization
  acip_transport_t *transport = g_client_transport;
  mutex_unlock(&g_send_mutex);
 
  // Network I/O happens OUTSIDE the mutex to prevent deadlock on TCP buffer full
  // Opus uses 20ms frames at 48kHz (960 samples = 20ms)
  asciichat_error_t result =
      acip_send_audio_opus_batch(transport, opus_data, opus_size, frame_sizes, frame_count, 48000, 20);
 
  // 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(), and server_connection_lost().

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 1306 of file src/client/server.c.

                                                                                      {
  // Connection and transport availability is checked by threaded_send_packet()
 
  // 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 crypto_client_get_context(), crypto_client_is_ready(), log_network_message(), 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 978 of file src/client/server.c.

                                                                                         {
  // Get transport reference while holding mutex (brief lock)
  mutex_lock(&g_send_mutex);
 
  // Check connection status and get transport reference
  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");
  }
 
  // Get transport reference - transport has its own internal synchronization
  acip_transport_t *transport = g_client_transport;
  mutex_unlock(&g_send_mutex);
 
  // Network I/O happens OUTSIDE the mutex to prevent deadlock on TCP buffer full
  asciichat_error_t result = packet_send_via_transport(transport, type, data, len, 0);
 
  // If send failed due to network error, signal connection loss
  if (result != ASCIICHAT_OK) {
    server_connection_lost();
    return result;
  }
 
  return ASCIICHAT_OK;
}

References packet_send_via_transport(), and server_connection_lost().

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 1158 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 threaded_send_packet().

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 1170 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 threaded_send_packet().

threaded_send_stream_start_packet()

asciichat_error_t 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 1183 of file src/client/server.c.

                                                                          {
  // Connection and transport availability is checked by threaded_send_packet()
 
  // 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 threaded_send_packet().

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

threaded_send_terminal_size_with_auto_detect()

asciichat_error_t 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 1206 of file src/client/server.c.

                                                                                                            {
  // Log the dimensions being sent to server (helps debug dimension mismatch issues)
  log_debug("Sending terminal size to server: %ux%u (auto_width=%d, auto_height=%d)", width, height,
            GET_OPTION(auto_width), GET_OPTION(auto_height));
 
  // Connection and transport availability is checked by threaded_send_packet()
 
  // Build terminal capabilities packet locally
  // Detect terminal capabilities automatically
  terminal_capabilities_t caps = detect_terminal_capabilities();
 
  // Set wants_padding based on snapshot mode and TTY status
  // Disable padding when:
  // - In snapshot mode (one frame and exit)
  // - When stdout is not a TTY (piped/redirected output)
  // Enable padding for interactive terminal sessions
  bool is_snapshot_mode = GET_OPTION(snapshot_mode);
  bool is_interactive = terminal_is_interactive();
  caps.wants_padding = is_interactive && !is_snapshot_mode;
 
  log_debug("Client capabilities: wants_padding=%d (snapshot=%d, interactive=%d, stdin_tty=%d, stdout_tty=%d)",
            caps.wants_padding, is_snapshot_mode, is_interactive, terminal_is_stdin_tty(), terminal_is_stdout_tty());
 
  // 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;
    // Preserve wants_padding even in fallback mode
    caps.wants_padding = is_interactive && !is_snapshot_mode;
  }
 
  // 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
  int fps = GET_OPTION(fps);
  if (fps > 0) {
    net_packet.desired_fps = (uint8_t)(fps > 144 ? 144 : 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;
  // Send UTF-8 support flag: true for AUTO (default) and TRUE settings, false for FALSE setting
  net_packet.utf8_support = (GET_OPTION(force_utf8) != UTF8_SETTING_FALSE) ? 1 : 0;
 
  // Set wants_padding flag (1=padding enabled, 0=no padding for snapshot/piped modes)
  net_packet.wants_padding = caps.wants_padding ? 1 : 0;
 
  // Use threaded_send_packet() which handles encryption
  return threaded_send_packet(PACKET_TYPE_CLIENT_CAPABILITIES, &net_packet, sizeof(net_packet));
}

References auto_height, auto_width, detect_terminal_capabilities(), options_get(), terminal_is_interactive(), terminal_is_stdin_tty(), terminal_is_stdout_tty(), and threaded_send_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.

Global crypto handshake context for this client connection.

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 196 of file src/client/server.c.

{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().