ascii-chat Client Main Entry Point More...

Functions
bool	should_exit ()
	Check if client should exit.

void	signal_exit ()
	Signal client to exit.

int	client_main (void)
	Client mode entry point for unified binary.

Variables
atomic_bool	g_should_exit = false

thread_pool_t *	g_client_worker_pool = NULL
	Global client worker thread pool.

tcp_client_t *	g_client = NULL
	Global TCP client instance.

struct webrtc_peer_manager *	g_peer_manager = NULL
	Global WebRTC peer manager for P2P connections.

Detailed Description

ascii-chat Client Main Entry Point

This module serves as the main entry point for the ascii-chat client application. It orchestrates the entire client lifecycle including initialization, connection management, and the primary event loop that manages reconnection logic.

Architecture Overview

The client follows a modular threading architecture:

Main thread: Connection management and event coordination
Data reception thread: Handles incoming packets from server
Ping thread: Maintains connection keepalive
Webcam capture thread: Captures and transmits video frames
Audio capture thread: Captures and transmits audio data (optional)

Connection Management

The client implements robust reconnection logic with exponential backoff:

Initial connection attempt
On connection loss, attempt reconnection with increasing delays
Maximum delay cap to prevent excessive wait times
Clean thread lifecycle management across reconnections

Thread Lifecycle

Each connection cycle follows this pattern:

Connection Establishment: Socket creation and server handshake
Thread Spawning: Start all worker threads for the connection
Active Monitoring: Monitor connection health and thread status
Connection Loss Detection: Detect broken connections via thread exit
Cleanup Phase: Join all threads and reset connection state
Reconnection Cycle: Repeat from step 1 unless shutdown requested

Integration Points

server.c: Connection establishment and socket management
protocol.c: Initial capability negotiation and join packets
display.c: Terminal initialization and control
capture.c: Media capture subsystem initialization
audio.c: Audio subsystem initialization (if enabled)
keepalive.c: Ping thread management

Error Handling

The main loop implements graceful error recovery:

Fatal initialization errors cause immediate exit
Network errors trigger reconnection attempts
Signal handling for graceful shutdown (SIGINT, SIGWINCH)
Resource cleanup on all exit paths

Platform Compatibility

Uses platform abstraction layer for:

Socket operations and network initialization
Thread management and synchronization
Signal handling differences between Unix and Windows
Terminal I/O and control sequences

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

Date: October 2025

Version: 2.0

Definition in file client/main.c.

Function Documentation

◆ client_main()

int client_main ( void )

Client mode entry point for unified binary.

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.

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.

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 = NULL

Global TCP client instance.

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 = NULL

Global client worker thread pool.

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 = NULL

Global WebRTC peer manager for P2P connections.

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

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

◆ g_should_exit

atomic_bool g_should_exit = false

Global flag indicating shutdown has been requested

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

Referenced by should_exit(), and signal_exit().

Functions

Variables