main.h File Reference

ascii-chat Client Mode Entry Point Header More...

Go to the source code of this file.

Functions
int	client_main (void)
	Client mode entry point for unified binary.
bool	should_exit (void)
	Check if client should exit.
void	signal_exit (void)
	Signal client to exit.

Variables
thread_pool_t *	g_client_worker_pool
	Global client worker thread pool.
tcp_client_t *	g_client
	Global TCP client instance.
struct webrtc_peer_manager *	g_peer_manager
	Global WebRTC peer manager for P2P connections.

Detailed Description

ascii-chat Client Mode Entry Point Header

This header exposes the client mode entry point for the unified binary architecture. The unified binary dispatches to client_main() when invoked as ascii-chat client.

Unified Binary Architecture

The ascii-chat application uses a single binary with multiple operating modes:

• ascii-chat server - Run as server (multi-client connection manager)
• ascii-chat client - Run as client (connects to server, streams video/audio)

This design provides several benefits:

• Simplified distribution (single binary to install)
• Reduced disk space (shared library code)
• Easier testing (one binary to build and deploy)
• Consistent versioning across modes

Mode Entry Point Contract

Each mode entry point (server_main, client_main) must:

• Accept no arguments: int mode_main(void)
• Options are already parsed by main dispatcher (available via global opt_* variables)
• Return 0 on success, non-zero error code on failure
• Perform mode-specific initialization and main loop
• Perform complete cleanup before returning

Implementation Notes

The client_main() function is the original main() from src/client/main.c, adapted to the new dispatcher pattern. Common initialization (options parsing, logging setup, lock debugging, –show-capabilities) now happens in src/main.c before dispatch.

Author

Zachary Fogg me@zf.nosp@m.o.gg

Date

2025

Version

2.0

Definition in file client/main.h.

Function Documentation

client_main()

int client_main

(

void

)

Client mode entry point for unified binary.

This function implements the complete client lifecycle including:

• Client-specific initialization (display, capture, audio)
• Server connection with reconnection logic
• Media streaming and frame display
• Graceful shutdown and cleanup

Options are already parsed by the main dispatcher before this function is called, so they are available via global opt_* variables.

Returns

0 on success, non-zero error code on failure

Example

# Invoked by dispatcher after options are parsed:
ascii-chat client --address localhost --audio
# Options parsed in main.c, then client_main() called

Client mode entry point for unified binary

Orchestrates the complete client lifecycle:

• System initialization and resource allocation
• Signal handler registration
• Main connection/reconnection loop
• Graceful shutdown and cleanup

Returns

0 on success, error code on failure

Definition at line 473 of file client/main.c.

                      {
  // Dispatcher already printed capabilities, but honor flag defensively
  if (GET_OPTION(show_capabilities)) {
    terminal_capabilities_t caps = detect_terminal_capabilities();
    caps = apply_color_mode_override(caps);
    print_terminal_capabilities(&caps);
    return 0;
  }
 
  // Initialize all client subsystems (shared init already completed)
  int init_result = initialize_client_systems(true);
  if (init_result != 0) {
    // Check if this is a webcam-related error and print help
    if (init_result == ERROR_WEBCAM || init_result == ERROR_WEBCAM_IN_USE || init_result == ERROR_WEBCAM_PERMISSION) {
      webcam_print_init_error_help(init_result);
      FATAL(init_result, "%s", asciichat_error_string(init_result));
    }
    // For other errors, just exit with the error code
    return init_result;
  }
 
  // Register cleanup function for graceful shutdown
  (void)atexit(shutdown_client);
 
  // Install console control handler for graceful Ctrl+C handling
  // Uses SetConsoleCtrlHandler on Windows, sigaction on Unix - more reliable than CRT signal()
  platform_set_console_ctrl_handler(console_ctrl_handler);
 
  // Install SIGWINCH handler for terminal resize (Unix only, no-op on Windows)
  platform_signal(SIGWINCH, sigwinch_handler);
 
#ifndef _WIN32
  // Ignore SIGPIPE - we'll handle write errors ourselves (not available on Windows)
  platform_signal(SIGPIPE, SIG_IGN);
#endif
 
  // Keep terminal logging enabled so user can see connection attempts
  // It will be disabled after first successful connection
  // Note: No initial terminal reset - display will only be cleared when first frame arrives
 
  // Track if we've ever successfully connected during this session
  static bool has_ever_connected = false;
 
  // Startup message only logged to file (terminal output is disabled by default)
 
  /* ========================================================================
   * Main Connection Loop
   * ========================================================================
   */
 
  int reconnect_attempt = 0;
  bool first_connection = true;
 
  // LAN Discovery: If --scan flag is set, discover servers on local network
  const options_t *opts = options_get();
  if (opts && opts->lan_discovery &&
      (opts->address[0] == '\0' || strcmp(opts->address, "127.0.0.1") == 0 ||
       strcmp(opts->address, "localhost") == 0)) {
    log_info("LAN discovery: --scan flag set, querying for available servers");
 
    discovery_tui_config_t lan_config;
    memset(&lan_config, 0, sizeof(lan_config));
    lan_config.timeout_ms = 2000; // Wait up to 2 seconds for responses
    lan_config.max_servers = 20;  // Support up to 20 servers on LAN
    lan_config.quiet = true;      // Quiet during discovery, TUI will show status
 
    int discovered_count = 0;
    discovery_tui_server_t *discovered_servers = discovery_tui_query(&lan_config, &discovered_count);
 
    // Use TUI for server selection
    int selected_index = discovery_tui_select(discovered_servers, discovered_count);
 
    if (selected_index < 0) {
      // User cancelled or no servers found
      if (discovered_count == 0) {
        // No servers found - print message and prevent any further output
        // Lock the terminal so other threads can't write
        log_lock_terminal();
 
        fprintf(stderr, "\n");
        fprintf(stderr, "No ASCII-Chat servers found on the local network.\n");
        fprintf(stderr, "Use 'ascii-chat client <address>' to connect manually.\n");
        fflush(stderr);
 
        // Log to file for debugging
        log_file_msg("\n");
        log_file_msg("No ASCII-Chat servers found on the local network.\n");
        log_file_msg("Use 'ascii-chat client <address>' to connect manually.\n");
 
        // Redirect stderr and stdout to /dev/null so cleanup handlers can't write to console
        // This is safe because we've already printed our final message
        int dev_null = open("/dev/null", O_WRONLY);
        if (dev_null >= 0) {
          dup2(dev_null, STDERR_FILENO);
          dup2(dev_null, STDOUT_FILENO);
          close(dev_null);
        }
 
        // Exit - cleanup handlers will try to write to /dev/null instead of console
        exit(1);
      }
      // User cancelled (had servers to choose from but pressed cancel)
      log_info("LAN discovery: User cancelled server selection");
      if (discovered_servers) {
        discovery_tui_free_results(discovered_servers);
      }
      return 1; // User cancelled
    }
 
    // Update options with discovered server's address and port
    discovery_tui_server_t *selected = &discovered_servers[selected_index];
    const char *selected_address = discovery_tui_get_best_address(selected);
 
    // We need to modify options, but they're immutable via RCU
    // Create a new options copy with updated address/port
    options_t *opts_new = SAFE_MALLOC(sizeof(options_t), options_t *);
    if (opts_new) {
      memcpy(opts_new, opts, sizeof(options_t));
      SAFE_STRNCPY(opts_new->address, selected_address, sizeof(opts_new->address));
 
      // Format port as string for compatibility
      char port_str[16];
      snprintf(port_str, sizeof(port_str), "%u", selected->port);
      SAFE_STRNCPY(opts_new->port, port_str, sizeof(opts_new->port));
 
      log_info("LAN discovery: Selected server '%s' at %s:%s", selected->name, opts_new->address, opts_new->port);
 
      // Note: In a real scenario, we'd update the global options via RCU
      // For now, we'll use the updated values directly for connection
      // This is a known limitation - proper RCU update requires more infrastructure
    }
 
    discovery_tui_free_results(discovered_servers);
  }
 
  // =========================================================================
  // Connection Fallback Context Setup
  // =========================================================================
  //
  // Initialize connection fallback context for 3-stage connection attempts:
  // 1. Direct TCP (3s timeout)
  // 2. WebRTC + STUN (8s timeout)
  // 3. WebRTC + TURN (15s timeout)
  //
  connection_attempt_context_t connection_ctx = {0};
  asciichat_error_t ctx_init_result =
      connection_context_init(&connection_ctx,
                              GET_OPTION(prefer_webrtc),      // --prefer-webrtc flag
                              GET_OPTION(no_webrtc),          // --no-webrtc flag
                              GET_OPTION(webrtc_skip_stun),   // --webrtc-skip-stun flag
                              GET_OPTION(webrtc_disable_turn) // --webrtc-disable-turn flag
      );
 
  if (ctx_init_result != ASCIICHAT_OK) {
    log_error("Failed to initialize connection context");
    return 1;
  }
 
  // =========================================================================
  // PHASE 1: Parallel mDNS + ACDS Session Discovery
  // =========================================================================
  //
  // When a session string is detected (e.g., "swift-river-mountain"),
  // we perform parallel discovery on both mDNS (local LAN) and ACDS (internet):
  //
  // 1. **mDNS Discovery**: Query _ascii-chat._tcp.local for servers with
  //    matching session_string in TXT records (2s timeout)
  // 2. **ACDS Discovery**: Lookup session on ACDS server (5s timeout)
  // 3. **Race to Success**: Return first successful result, cancel the other
  // 4. **Verification**: Check host_pubkey against --server-key or --acds-insecure
  //
  // Usage modes:
  // - `ascii-chat swift-river-mountain` → mDNS-only (local LAN, no verification)
  // - `ascii-chat --server-key PUBKEY swift-river-mountain` → verified
  // - `ascii-chat --acds-insecure swift-river-mountain` → parallel without verification
  //
  const char *discovered_address = NULL;
  const char *discovered_port = NULL;
 
  const options_t *opts_discovery = options_get();
  const char *session_string =
      opts_discovery && opts_discovery->session_string[0] != '\0' ? opts_discovery->session_string : "";
 
  if (session_string[0] != '\0') {
    log_info("Session string detected: '%s' - performing parallel discovery (mDNS + ACDS)", session_string);
 
    // Configure discovery coordinator
    discovery_config_t discovery_cfg;
    discovery_config_init_defaults(&discovery_cfg);
 
    // Parse expected server key if provided
    uint8_t expected_pubkey[32];
    memset(expected_pubkey, 0, 32);
    if (opts_discovery && opts_discovery->server_key[0] != '\0') {
      asciichat_error_t parse_err = hex_to_pubkey(opts_discovery->server_key, expected_pubkey);
      if (parse_err == ASCIICHAT_OK) {
        discovery_cfg.expected_pubkey = expected_pubkey;
        log_info("Server key verification enabled");
      } else {
        log_warn("Failed to parse server key - skipping verification");
      }
    }
 
    // Enable insecure mode if requested
    if (opts_discovery && opts_discovery->acds_insecure) {
      discovery_cfg.insecure_mode = true;
      log_warn("ACDS insecure mode enabled - no server key verification");
    }
 
    // Configure ACDS connection details
    if (opts_discovery && opts_discovery->acds_server[0] != '\0') {
      SAFE_STRNCPY(discovery_cfg.acds_server, opts_discovery->acds_server, sizeof(discovery_cfg.acds_server));
    }
    if (opts_discovery && opts_discovery->acds_port > 0) {
      discovery_cfg.acds_port = (uint16_t)opts_discovery->acds_port;
    }
 
    // Set password for session join (use pointer since it persists through discovery)
    if (opts_discovery && opts_discovery->password[0] != '\0') {
      discovery_cfg.password = opts_discovery->password; // Safe: opts_discovery from options_get() persists
      log_debug("Password configured for session join");
    }
 
    // Perform parallel discovery
    discovery_result_t discovery_result;
    memset(&discovery_result, 0, sizeof(discovery_result));
    asciichat_error_t discovery_err = discover_session_parallel(session_string, &discovery_cfg, &discovery_result);
 
    if (discovery_err != ASCIICHAT_OK || !discovery_result.success) {
      fprintf(stderr, "Error: Failed to discover session '%s'\n", session_string);
      fprintf(stderr, "  - Not found via mDNS (local network)\n");
      fprintf(stderr, "  - Not found via ACDS (discovery server)\n");
      fprintf(stderr, "\nDid you mean to:\n");
      fprintf(stderr, "  ascii-chat server           # Start a new server\n");
      fprintf(stderr, "  ascii-chat client           # Connect to localhost\n");
      fprintf(stderr, "  ascii-chat client HOST      # Connect to specific host\n");
      return 1;
    }
 
    // Log discovery result
    const char *source_name = discovery_result.source == DISCOVERY_SOURCE_MDNS ? "mDNS (LAN)" : "ACDS (internet)";
    log_info("Session discovered via %s: %s:%d", source_name, discovery_result.server_address,
             discovery_result.server_port);
 
    // Set discovered address/port for connection
    // Copy to static buffers since discovery_result goes out of scope after this block
    static char address_buffer[256];
    static char port_buffer[8];
    SAFE_STRNCPY(address_buffer, discovery_result.server_address, sizeof(address_buffer));
    snprintf(port_buffer, sizeof(port_buffer), "%d", discovery_result.server_port);
    discovered_address = address_buffer;
    discovered_port = port_buffer;
 
    // Populate session context for WebRTC fallback (if discovery came from ACDS)
    if (discovery_result.source == DISCOVERY_SOURCE_ACDS) {
      SAFE_STRNCPY(connection_ctx.session_ctx.session_string, session_string,
                   sizeof(connection_ctx.session_ctx.session_string));
      memcpy(connection_ctx.session_ctx.session_id, discovery_result.session_id, 16);
      memcpy(connection_ctx.session_ctx.participant_id, discovery_result.participant_id, 16);
      SAFE_STRNCPY(connection_ctx.session_ctx.server_address, discovery_result.server_address,
                   sizeof(connection_ctx.session_ctx.server_address));
      connection_ctx.session_ctx.server_port = discovery_result.server_port;
      log_debug("Populated session context for WebRTC fallback (session='%s')", session_string);
    }
 
    log_info("Connecting to server: %s:%d", discovered_address, discovery_result.server_port);
  }
 
  const options_t *opts_conn = options_get();
  while (!should_exit()) {
    // Handle connection establishment or reconnection
    const char *address = discovered_address
                              ? discovered_address
                              : (opts_conn && opts_conn->address[0] != '\0' ? opts_conn->address : "localhost");
    const char *port_str =
        discovered_port ? discovered_port : (opts_conn && opts_conn->port[0] != '\0' ? opts_conn->port : "27224");
    int port = atoi(port_str);
 
    // Update connection context with current attempt number
    connection_ctx.reconnect_attempt = reconnect_attempt;
 
    // Get ACDS server configuration from CLI options (defaults: 127.0.0.1:27225)
    const char *acds_server = GET_OPTION(acds_server);
    if (!acds_server || acds_server[0] == '\0') {
      acds_server = "127.0.0.1"; // Fallback if option not set
    }
    int acds_port = GET_OPTION(acds_port);
    if (acds_port <= 0 || acds_port > 65535) {
      acds_port = 27225; // Fallback to default ACDS port
    }
 
    // Attempt connection with 3-stage fallback (TCP → STUN → TURN)
    asciichat_error_t connection_result =
        connection_attempt_with_fallback(&connection_ctx, address, (uint16_t)port, acds_server, (uint16_t)acds_port);
 
    // Check if connection attempt succeeded
    // Handle the error result appropriately
    int connection_success = (connection_result == ASCIICHAT_OK) ? 0 : -1;
 
    if (connection_success != 0) {
      // TODO Part 5: Handle specific error codes from connection_result
      // For now, treat all non-OK results as connection failure
      // Authentication errors would be returned as ERROR_CRYPTO_HANDSHAKE
 
      // In snapshot mode, exit immediately on connection failure - no retries
      // Snapshot mode is for quick single-frame captures, not persistent connections
      if (GET_OPTION(snapshot_mode)) {
        log_error("Connection failed in snapshot mode - exiting without retry");
        return 1;
      }
 
      // Connection failed - check if we should retry based on --reconnect setting
      reconnect_attempt++;
 
      // Get reconnect attempts setting (-1 = unlimited, 0 = no retry, >0 = retry N times)
      int reconnect_attempts = GET_OPTION(reconnect_attempts);
 
      // Check reconnection policy
      if (reconnect_attempts == 0) {
        // --reconnect off: Exit immediately on first failure
        log_error("Connection failed (reconnection disabled via --reconnect off)");
        return 1;
      } else if (reconnect_attempts > 0 && reconnect_attempt > reconnect_attempts) {
        // --reconnect N: Exceeded max retry attempts
        log_error("Connection failed after %d attempts (limit set by --reconnect %d)", reconnect_attempt - 1,
                  reconnect_attempts);
        return 1;
      }
      // else: reconnect_attempts == -1 (auto) means retry forever
 
      if (has_ever_connected) {
        display_full_reset();
        log_set_terminal_output(true);
      } else {
        // Add newline to separate from ASCII art display for first-time connection failures
        printf("\n");
      }
 
      if (has_ever_connected) {
        if (reconnect_attempts == -1) {
          log_info("Reconnection attempt #%d... (unlimited retries)", reconnect_attempt);
        } else {
          log_info("Reconnection attempt #%d/%d...", reconnect_attempt, reconnect_attempts);
        }
      } else {
        if (reconnect_attempts == -1) {
          log_info("Connection attempt #%d... (unlimited retries)", reconnect_attempt);
        } else {
          log_info("Connection attempt #%d/%d...", reconnect_attempt, reconnect_attempts);
        }
      }
 
      // Continue retrying based on reconnection policy
      continue;
    }
 
    // Connection successful - reset counters and flags
    reconnect_attempt = 0;
    first_connection = false;
 
    // Integrate the active transport from connection fallback into server connection layer
    // (Transport is TCP for Stage 1, WebRTC DataChannel for Stages 2/3)
    if (connection_ctx.active_transport) {
      server_connection_set_transport(connection_ctx.active_transport);
      log_debug("Active transport integrated into server connection layer");
    } else {
      log_error("Connection succeeded but no active transport - this should never happen");
      continue; // Retry connection
    }
 
    // Show appropriate connection message based on whether this is first connection or reconnection
    if (!has_ever_connected) {
      log_info("Connected successfully, starting worker threads");
      has_ever_connected = true;
    } else {
      log_info("Reconnected successfully, starting worker threads");
    }
 
    // Start all worker threads for this connection
    if (protocol_start_connection() != 0) {
      log_error("Failed to start connection protocols");
      server_connection_close();
 
      // In snapshot mode, exit immediately on protocol failure - no retries
      if (GET_OPTION(snapshot_mode)) {
        log_error("Protocol startup failed in snapshot mode - exiting without retry");
        return 1;
      }
 
      continue;
    }
 
    // Terminal logging is now disabled - ASCII display can begin cleanly
    // Don't clear terminal here - let the first frame handler clear it
    // This prevents clearing the terminal before we're ready to display content
 
    /* ====================================================================
     * Connection Monitoring Loop
     * ====================================================================
     */
 
    // Monitor connection health until it breaks or shutdown is requested
    while (!should_exit() && server_connection_is_active()) {
      // Check if any critical threads have exited (indicates connection lost)
      if (protocol_connection_lost()) {
        log_info("Connection lost detected by protocol threads");
        break;
      }
 
      platform_sleep_usec(100 * 1000); // 0.1 second monitoring interval
    }
 
    if (should_exit()) {
      log_info("Shutdown requested, exiting main loop");
      break;
    }
 
    // Connection broken - clean up this connection and prepare for reconnect
    log_info("Connection lost, cleaning up for reconnection");
 
    // Re-enable terminal logging when connection is lost for debugging reconnection
    // (but only if we've ever successfully connected before)
    if (has_ever_connected) {
      printf("\n");
      log_set_terminal_output(true);
    }
 
    protocol_stop_connection();
    server_connection_close();
 
    // In snapshot mode, exit immediately on connection loss - no reconnection
    // Snapshot mode is for quick single-frame captures, not persistent connections
    if (GET_OPTION(snapshot_mode)) {
      log_error("Connection lost in snapshot mode - exiting without reconnection");
      return 1;
    }
 
    // Add a brief delay before attempting reconnection to prevent excessive reconnection loops
    if (has_ever_connected) {
      log_info("Waiting 1 second before attempting reconnection...");
      platform_sleep_usec(1000000); // 1 second delay
    }
 
    log_info("Cleanup complete, will attempt reconnection");
  }
 
  // Cleanup connection context (closes any active transports)
  connection_context_cleanup(&connection_ctx);
 
  log_info("ascii-chat client shutting down");
  return 0;
}

References options_state::acds_insecure, discovery_config_t::acds_port, options_state::acds_port, discovery_config_t::acds_server, options_state::acds_server, connection_attempt_context_t::active_transport, options_state::address, apply_color_mode_override(), ASCIICHAT_OK, connection_attempt_with_fallback(), connection_context_cleanup(), connection_context_init(), detect_terminal_capabilities(), discover_session_parallel(), discovery_config_init_defaults(), discovery_tui_free_results(), discovery_tui_get_best_address(), discovery_tui_query(), discovery_tui_select(), display_full_reset(), ERROR_WEBCAM, ERROR_WEBCAM_IN_USE, ERROR_WEBCAM_PERMISSION, discovery_config_t::expected_pubkey, FATAL, GET_OPTION, hex_to_pubkey(), discovery_config_t::insecure_mode, options_state::lan_discovery, log_debug, log_error, log_file_msg(), log_info, log_lock_terminal(), log_set_terminal_output(), log_warn, discovery_tui_config_t::max_servers, discovery_tui_server_t::name, options_get(), discovery_result_t::participant_id, connection_session_context_t::participant_id, discovery_config_t::password, options_state::password, platform_set_console_ctrl_handler(), platform_signal(), platform_sleep_usec(), discovery_tui_server_t::port, options_state::port, print_terminal_capabilities(), protocol_connection_lost(), protocol_start_connection(), protocol_stop_connection(), discovery_tui_config_t::quiet, connection_attempt_context_t::reconnect_attempt, SAFE_MALLOC, SAFE_STRNCPY, discovery_result_t::server_address, connection_session_context_t::server_address, server_connection_close(), server_connection_is_active(), server_connection_set_transport(), options_state::server_key, discovery_result_t::server_port, connection_session_context_t::server_port, connection_attempt_context_t::session_ctx, discovery_result_t::session_id, connection_session_context_t::session_id, connection_session_context_t::session_string, options_state::session_string, should_exit(), discovery_result_t::source, discovery_result_t::success, discovery_tui_config_t::timeout_ms, and webcam_print_init_error_help().

should_exit()

bool should_exit

(

void

)

Check if client should exit.

Thread-safe check of the global exit flag. Used by all client threads to coordinate graceful shutdown.

Returns

true if exit signal received, false otherwise

Check if shutdown has been requested

Returns

true if shutdown requested, false otherwise

Definition at line 160 of file client/main.c.

                   {
  return atomic_load(&g_should_exit);
}

References g_should_exit.

Referenced by __attribute__(), client_main(), client_receive_thread(), display_full_reset(), and server_connection_establish().

signal_exit()

void signal_exit

(

void

)

Signal client to exit.

Sets the global exit flag to trigger graceful shutdown of all client threads. Thread-safe and can be called from signal handlers.

Signal that shutdown should be requested

Definition at line 167 of file client/main.c.

                   {
  atomic_store(&g_should_exit, true);
}

References g_should_exit.

Variable Documentation

g_client

tcp_client_t* g_client

extern

Global TCP client instance.

Central connection and state management structure for the client. Replaces scattered global variables from server.c, protocol.c, audio.c, etc. Follows the same pattern as tcp_server_t used by the server.

This instance provides:

• Connection state management (socket, server address, client ID)
• Thread-safe packet transmission with mutex protection
• Audio queue management for async audio streaming
• Crypto handshake context for encrypted connections
• Terminal capability tracking for rendering

Initialized by tcp_client_create() in client_main(). Destroyed by tcp_client_destroy() at cleanup.

All client modules (server.c, protocol.c, audio.c, capture.c, display.c) should use this instance instead of accessing global connection state.

Global TCP client instance

Central connection and state management structure for the client. Replaces scattered global variables from server.c, protocol.c, audio.c, etc. Follows the same pattern as tcp_server_t used by the server.

Initialized by tcp_client_create() in client_main(). Destroyed by tcp_client_destroy() at cleanup.

Definition at line 146 of file client/main.c.

g_client_worker_pool

thread_pool_t* g_client_worker_pool

extern

Global client worker thread pool.

Manages all client worker threads including:

• Data reception thread (protocol.c)
• Webcam capture thread (capture.c)
• Ping/keepalive thread (keepalive.c)
• Audio capture thread (audio.c)
• Audio sender thread (audio.c)

This pool is initialized in client_main() and accessible from all client modules for spawning and managing worker threads.

Global client worker thread pool

Manages all client worker threads including:

• Data reception thread (protocol.c)
• Webcam capture thread (capture.c)
• Ping/keepalive thread (keepalive.c)
• Audio capture thread (audio.c)
• Audio sender thread (audio.c)

Definition at line 134 of file client/main.c.

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

g_peer_manager

struct webrtc_peer_manager* g_peer_manager

extern

Global WebRTC peer manager for P2P connections.

Manages WebRTC peer connections for ACDS session participants. Handles SDP/ICE exchange and DataChannel lifecycle for P2P ACIP transport.

NULL if WebRTC not initialized (TCP-only mode). Initialized when joining/creating ACDS sessions with WebRTC transport.

NULL if WebRTC not initialized. Initialized when joining/creating ACDS sessions.

Definition at line 153 of file client/main.c.