connection_attempt.c File Reference

TCP connection handler for client mode. More...

Go to the source code of this file.

Functions
const char *	connection_state_name (connection_state_t state)
	Get human-readable state name for logging.
asciichat_error_t	connection_context_init (connection_attempt_context_t *ctx)
	Initialize connection attempt context.
void	connection_context_cleanup (connection_attempt_context_t *ctx)
	Cleanup connection attempt context.
asciichat_error_t	connection_state_transition (connection_attempt_context_t *ctx, connection_state_t new_state)
	Transition to next connection state with validation.
bool	connection_check_timeout (const connection_attempt_context_t *ctx)
	Check if connection attempt has exceeded timeout.
asciichat_error_t	connection_attempt_tcp (connection_attempt_context_t *ctx, const char *server_address, uint16_t server_port, struct tcp_client *pre_created_tcp_client)
	Attempt direct TCP connection.
asciichat_error_t	connection_attempt_websocket (connection_attempt_context_t *ctx, const char *ws_url)
	Attempt WebSocket connection (ws:// or wss://)

Detailed Description

TCP connection handler for client mode.

Implements direct TCP connection for client mode. Client mode uses direct TCP connections only - no WebRTC fallback.

Features:

• Direct TCP connection to server
• Timeout management
• Proper resource cleanup
• Detailed logging of connection attempts

Integration Points:

• Called from src/client/main.c connection loop
• Returns active transport when connection succeeds

Date

January 2026

Version

2.0

Definition in file connection_attempt.c.

Function Documentation

connection_attempt_tcp()

asciichat_error_t connection_attempt_tcp	(	connection_attempt_context_t *	ctx,
		const char *	server_address,
		uint16_t	server_port,
		struct tcp_client *	pre_created_tcp_client
	)

Attempt direct TCP connection.

Attempt TCP connection.

Connects to server via TCP, performs crypto handshake if enabled, and creates ACIP transport for protocol communication.

Definition at line 177 of file connection_attempt.c.

                                                                                                          {
  log_info("=== connection_attempt_tcp CALLED: address='%s', port=%u, pre_created=%p ===", server_address, server_port,
           (void *)pre_created_tcp_client);
 
  if (!ctx || !server_address) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Check if shutdown was requested before attempting connection
  if (should_exit()) {
    return SET_ERRNO(ERROR_NETWORK, "Connection attempt aborted due to shutdown request");
  }
 
  // Check for WebSocket URL - handle separately from TCP
  log_debug("connection_attempt_tcp: server_address='%s', port=%u", server_address, server_port);
 
  if (url_is_websocket(server_address)) {
    // WebSocket connection path
    const char *ws_url = server_address;
 
    // Parse for debug logging
    url_parts_t url_parts = {0};
    if (url_parse(server_address, &url_parts) == ASCIICHAT_OK) {
      log_debug("WebSocket URL parsed: host=%s, port=%d, scheme=%s", url_parts.host, url_parts.port, url_parts.scheme);
    }
 
    log_info("Attempting WebSocket connection to %s", ws_url);
 
    // Transition to attempting state
    asciichat_error_t result = connection_state_transition(ctx, CONN_STATE_ATTEMPTING);
    if (result != ASCIICHAT_OK) {
      url_parts_destroy(&url_parts);
      return result;
    }
 
    // Set timeout for this attempt
    ctx->attempt_start_time_ns = time_get_realtime_ns();
    ctx->timeout_ns = CONN_TIMEOUT_TCP; // Use same timeout as TCP
 
    // Compute crypto mode from CLI options
    // Determine if client has authentication material (keys or password)
    bool has_auth_material =
        (GET_OPTION(encrypt_key)[0] != '\0' || GET_OPTION(num_identity_keys) > 0 || GET_OPTION(password)[0] != '\0');
    bool no_encrypt = GET_OPTION(no_encrypt);
 
    uint8_t crypto_mode;
    if (!no_encrypt && !has_auth_material)
      crypto_mode = ACIP_CRYPTO_ENCRYPT; // default: encrypt only
    else if (!no_encrypt && has_auth_material)
      crypto_mode = ACIP_CRYPTO_FULL; // full: encrypt + auth
    else if (no_encrypt && has_auth_material)
      crypto_mode = ACIP_CRYPTO_AUTH; // auth-only mode
    else
      crypto_mode = ACIP_CRYPTO_NONE; // no crypto
 
    log_debug("WebSocket crypto mode computed: 0x%02x (encrypt=%d, auth=%d)", crypto_mode,
              ACIP_CRYPTO_HAS_ENCRYPT(crypto_mode), ACIP_CRYPTO_HAS_AUTH(crypto_mode));
 
    // Set crypto mode before initialization
    client_crypto_set_mode(crypto_mode);
 
    // Initialize crypto context if mode requires handshake (not ACIP_CRYPTO_NONE)
    if (crypto_mode != ACIP_CRYPTO_NONE) {
      log_debug("Initializing crypto context for WebSocket...");
      if (client_crypto_init() != 0) {
        log_error("Failed to initialize crypto context");
        url_parts_destroy(&url_parts);
        return SET_ERRNO(ERROR_CRYPTO, "Crypto initialization failed");
      }
      log_debug("Crypto context initialized successfully");
    }
 
    // Get crypto context
    const crypto_context_t *crypto_ctx = crypto_client_is_ready() ? crypto_client_get_context() : NULL;
 
    // Create WebSocket client instance
    websocket_client_t *ws_client = websocket_client_create();
    if (!ws_client) {
      log_error("Failed to create WebSocket client");
      connection_state_transition(ctx, CONN_STATE_FAILED);
      url_parts_destroy(&url_parts);
      return SET_ERRNO(ERROR_NETWORK, "WebSocket client creation failed");
    }
 
    // Connect via WebSocket
    acip_transport_t *transport = websocket_client_connect(ws_client, ws_url, (crypto_context_t *)crypto_ctx);
    if (!transport) {
      log_error("Failed to create WebSocket ACIP transport");
      websocket_client_destroy(&ws_client);
      connection_state_transition(ctx, CONN_STATE_FAILED);
      url_parts_destroy(&url_parts);
      return SET_ERRNO(ERROR_NETWORK, "WebSocket connection failed");
    }
 
    log_info("WebSocket connection established to %s", ws_url);
    connection_state_transition(ctx, CONN_STATE_CONNECTED);
    ctx->active_transport = transport;
    ctx->ws_client_instance = ws_client;
    url_parts_destroy(&url_parts);
    return ASCIICHAT_OK;
  }
 
  // TCP connection path (original logic)
  log_info("Attempting TCP connection to %s:%u (3s timeout)", server_address, server_port);
 
  // Transition to attempting state
  asciichat_error_t result = connection_state_transition(ctx, CONN_STATE_ATTEMPTING);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  // Use pre-created TCP client if provided, otherwise create one
  tcp_client_t *tcp_client = pre_created_tcp_client;
  bool created_tcp_client = false;
  if (!tcp_client) {
    tcp_client = tcp_client_create();
    created_tcp_client = true;
    if (!tcp_client) {
      log_error("Failed to create TCP client");
      connection_state_transition(ctx, CONN_STATE_FAILED);
      return SET_ERRNO(ERROR_NETWORK, "TCP client creation failed");
    }
    log_debug("Created TCP client locally (not pre-created by framework)");
  } else {
    log_debug("Using pre-created TCP client from framework");
  }
 
  // Set timeout for this attempt
  ctx->attempt_start_time_ns = time_get_realtime_ns();
  ctx->timeout_ns = CONN_TIMEOUT_TCP;
 
  // Attempt TCP connection (reconnect_attempt is 0-based, convert for tcp_client_connect)
  int tcp_result = tcp_client_connect(tcp_client, server_address, server_port, (int)ctx->reconnect_attempt,
                                      ctx->reconnect_attempt == 0, ctx->reconnect_attempt > 0);
 
  if (tcp_result != 0) {
    log_debug("TCP connection failed (tcp_client_connect returned %d)", tcp_result);
    if (created_tcp_client) {
      tcp_client_destroy(&tcp_client);
    }
    connection_state_transition(ctx, CONN_STATE_FAILED);
    return SET_ERRNO(ERROR_NETWORK, "TCP connection failed after %u attempts", ctx->reconnect_attempt);
  }
 
  // Extract socket from TCP client for crypto handshake
  socket_t sockfd = tcp_client_get_socket(tcp_client);
  if (sockfd == INVALID_SOCKET_VALUE) {
    log_error("Failed to get socket from TCP client");
    if (created_tcp_client) {
      tcp_client_destroy(&tcp_client);
    }
    return SET_ERRNO(ERROR_NETWORK, "Invalid socket after TCP connection");
  }
 
  // Extract and set server IP for crypto context initialization
  // TCP client already resolved and connected to the server IP, stored in tcp_client->server_ip
  if (tcp_client->server_ip[0] != '\0') {
    server_connection_set_ip(tcp_client->server_ip);
    log_debug("Server IP extracted from TCP client: %s", tcp_client->server_ip);
  } else {
    log_warn("TCP client did not populate server_ip field");
  }
 
  // Compute crypto mode from CLI options
  // Determine if client has authentication material (keys or password)
  bool has_auth_material =
      (GET_OPTION(encrypt_key)[0] != '\0' || GET_OPTION(num_identity_keys) > 0 || GET_OPTION(password)[0] != '\0');
  bool no_encrypt = GET_OPTION(no_encrypt);
 
  uint8_t crypto_mode;
  if (!no_encrypt && !has_auth_material)
    crypto_mode = ACIP_CRYPTO_ENCRYPT; // default: encrypt only
  else if (!no_encrypt && has_auth_material)
    crypto_mode = ACIP_CRYPTO_FULL; // full: encrypt + auth
  else if (no_encrypt && has_auth_material)
    crypto_mode = ACIP_CRYPTO_AUTH; // auth-only mode
  else
    crypto_mode = ACIP_CRYPTO_NONE; // no crypto
 
  log_debug("TCP crypto mode computed: 0x%02x (encrypt=%d, auth=%d)", crypto_mode, ACIP_CRYPTO_HAS_ENCRYPT(crypto_mode),
            ACIP_CRYPTO_HAS_AUTH(crypto_mode));
 
  // Set crypto mode before initialization
  client_crypto_set_mode(crypto_mode);
 
  // Initialize crypto context if mode requires handshake (not ACIP_CRYPTO_NONE)
  // This must happen AFTER setting server IP, as crypto init reads server IP/port
  if (crypto_mode != ACIP_CRYPTO_NONE) {
    log_debug("Initializing crypto context...");
    if (client_crypto_init() != 0) {
      log_error("Failed to initialize crypto context");
      if (created_tcp_client) {
        tcp_client_destroy(&tcp_client);
      }
      return SET_ERRNO(ERROR_CRYPTO, "Crypto initialization failed");
    }
    log_debug("Crypto context initialized successfully");
 
    // Perform crypto handshake with server
    log_debug("Performing crypto handshake with server...");
    if (client_crypto_handshake(sockfd) != 0) {
      log_error("Crypto handshake failed");
      if (created_tcp_client) {
        tcp_client_destroy(&tcp_client);
      }
      return SET_ERRNO(ERROR_NETWORK, "Crypto handshake failed");
    }
    log_debug("Crypto handshake completed successfully");
  }
 
  // Get crypto context after handshake
  const crypto_context_t *crypto_ctx = crypto_client_is_ready() ? crypto_client_get_context() : NULL;
 
  // Create ACIP transport for protocol-agnostic packet sending/receiving
  acip_transport_t *transport = acip_tcp_transport_create(sockfd, (crypto_context_t *)crypto_ctx);
  if (!transport) {
    log_error("Failed to create ACIP transport for TCP");
    if (created_tcp_client) {
      tcp_client_destroy(&tcp_client);
    }
    return SET_ERRNO(ERROR_NETWORK, "Failed to create ACIP transport");
  }
 
  log_info("TCP connection established to %s:%u", server_address, server_port);
  connection_state_transition(ctx, CONN_STATE_CONNECTED);
  ctx->active_transport = transport;
 
  // Store tcp_client in context for proper lifecycle management only if we created it locally
  // If it's pre-created by the framework, the framework will manage its lifecycle
  if (created_tcp_client) {
    ctx->tcp_client_instance = tcp_client;
    log_debug("TCP client instance stored in connection context for cleanup");
  } else {
    log_debug("Using framework-managed TCP client, not storing in context");
  }
 
  return ASCIICHAT_OK;
}

References acip_tcp_transport_create(), connection_attempt_context_t::active_transport, connection_attempt_context_t::attempt_start_time_ns, client_crypto_handshake(), client_crypto_init(), client_crypto_set_mode(), CONN_STATE_ATTEMPTING, CONN_STATE_CONNECTED, CONN_STATE_FAILED, CONN_TIMEOUT_TCP, connection_state_transition(), crypto_client_get_context(), crypto_client_is_ready(), connection_attempt_context_t::reconnect_attempt, server_connection_set_ip(), should_exit(), tcp_client_connect(), tcp_client_create(), tcp_client_destroy(), tcp_client_get_socket(), connection_attempt_context_t::tcp_client_instance, time_get_realtime_ns(), connection_attempt_context_t::timeout_ns, url_is_websocket(), url_parse(), url_parts_destroy(), websocket_client_connect(), websocket_client_create(), websocket_client_destroy(), and connection_attempt_context_t::ws_client_instance.

connection_attempt_websocket()

asciichat_error_t connection_attempt_websocket	(	connection_attempt_context_t *	ctx,
		const char *	ws_url
	)

Attempt WebSocket connection (ws:// or wss://)

Attempt WebSocket connection.

Connects to server via WebSocket, performs crypto handshake if enabled, and creates ACIP transport for protocol communication.

Definition at line 423 of file connection_attempt.c.

                                                                                                      {
  log_info("=== connection_attempt_websocket CALLED: url='%s' ===", ws_url);
 
  if (!ctx || !ws_url) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Check if shutdown was requested
  if (should_exit()) {
    return SET_ERRNO(ERROR_NETWORK, "Connection attempt aborted due to shutdown request");
  }
 
  log_info("Attempting WebSocket connection to %s", ws_url);
 
  // Transition to attempting state
  asciichat_error_t result = connection_state_transition(ctx, CONN_STATE_ATTEMPTING);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  // Set timeout for this attempt
  ctx->attempt_start_time_ns = time_get_realtime_ns();
  ctx->timeout_ns = CONN_TIMEOUT_TCP;
 
  // Initialize crypto context if encryption is enabled
  if (!GET_OPTION(no_encrypt)) {
    log_debug("Initializing crypto context for WebSocket...");
    if (client_crypto_init() != 0) {
      log_error("Failed to initialize crypto context");
      return SET_ERRNO(ERROR_CRYPTO, "Crypto initialization failed");
    }
    log_debug("Crypto context initialized successfully");
  }
 
  // Get crypto context
  const crypto_context_t *crypto_ctx = crypto_client_is_ready() ? crypto_client_get_context() : NULL;
 
  // Create WebSocket client instance
  websocket_client_t *ws_client = websocket_client_create();
  if (!ws_client) {
    log_error("Failed to create WebSocket client");
    connection_state_transition(ctx, CONN_STATE_FAILED);
    return SET_ERRNO(ERROR_NETWORK, "WebSocket client creation failed");
  }
 
  // Connect via WebSocket
  acip_transport_t *transport = websocket_client_connect(ws_client, ws_url, (crypto_context_t *)crypto_ctx);
  if (!transport) {
    log_error("Failed to create WebSocket ACIP transport");
    websocket_client_destroy(&ws_client);
    connection_state_transition(ctx, CONN_STATE_FAILED);
    return SET_ERRNO(ERROR_NETWORK, "WebSocket connection failed");
  }
 
  log_info("WebSocket connection established to %s", ws_url);
  connection_state_transition(ctx, CONN_STATE_CONNECTED);
  ctx->active_transport = transport;
  ctx->ws_client_instance = ws_client;
  log_debug("WebSocket client instance stored in connection context");
 
  return ASCIICHAT_OK;
}

References connection_attempt_context_t::active_transport, connection_attempt_context_t::attempt_start_time_ns, client_crypto_init(), CONN_STATE_ATTEMPTING, CONN_STATE_CONNECTED, CONN_STATE_FAILED, CONN_TIMEOUT_TCP, connection_state_transition(), crypto_client_get_context(), crypto_client_is_ready(), should_exit(), time_get_realtime_ns(), connection_attempt_context_t::timeout_ns, websocket_client_connect(), websocket_client_create(), websocket_client_destroy(), and connection_attempt_context_t::ws_client_instance.

connection_check_timeout()

bool connection_check_timeout

(

const connection_attempt_context_t *

ctx

)

Check if connection attempt has exceeded timeout.

Compares elapsed time since attempt start against timeout.

Parameters

ctx	Connection context

Returns

true if timeout exceeded, false otherwise

Definition at line 152 of file connection_attempt.c.

                                                                       {
  if (!ctx)
    return false;
 
  uint64_t elapsed_ns = time_get_realtime_ns() - ctx->attempt_start_time_ns;
  bool timeout_exceeded = elapsed_ns > ctx->timeout_ns;
 
  if (timeout_exceeded) {
    log_warn("Connection timeout exceeded: elapsed %.3f seconds > %.3f seconds limit", time_ns_to_s(elapsed_ns),
             time_ns_to_s(ctx->timeout_ns));
  }
 
  return timeout_exceeded;
}

References connection_attempt_context_t::attempt_start_time_ns, time_get_realtime_ns(), and connection_attempt_context_t::timeout_ns.

connection_context_cleanup()

void connection_context_cleanup

(

connection_attempt_context_t *

ctx

)

Cleanup connection attempt context.

Closes and releases any active transports, frees WebRTC peer manager. Called on connection success, failure, or shutdown.

Parameters

ctx	Connection context to cleanup

Definition at line 102 of file connection_attempt.c.

                                                                   {
  if (!ctx)
    return;
 
  // Destroy TCP client instance if created
  if (ctx->tcp_client_instance) {
    tcp_client_destroy(&ctx->tcp_client_instance);
    ctx->tcp_client_instance = NULL;
    log_debug("TCP client instance destroyed");
  }
 
  // Destroy WebSocket client instance if created
  if (ctx->ws_client_instance) {
    websocket_client_destroy(&ctx->ws_client_instance);
    ctx->ws_client_instance = NULL;
    log_debug("WebSocket client instance destroyed");
  }
 
  // Close active transport if still open
  if (ctx->active_transport) {
    acip_transport_close(ctx->active_transport);
    acip_transport_destroy(ctx->active_transport);
    ctx->active_transport = NULL;
    log_debug("Transport connection closed");
  }
 
  log_debug("Connection context cleaned up");
}

References acip_transport_destroy(), connection_attempt_context_t::active_transport, tcp_client_destroy(), connection_attempt_context_t::tcp_client_instance, websocket_client_destroy(), and connection_attempt_context_t::ws_client_instance.

Referenced by client_main().

connection_context_init()

asciichat_error_t connection_context_init

(

connection_attempt_context_t *

ctx

)

Initialize connection attempt context.

Sets up initial state, resets timeouts, and prepares for connection attempt.

Parameters

ctx	Connection context to initialize

Returns

ASCIICHAT_OK on success, error code otherwise

Definition at line 74 of file connection_attempt.c.

                                                                             {
  if (!ctx) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Context pointer is NULL");
  }
 
  // Reset context
  memset(ctx, 0, sizeof(connection_attempt_context_t));
 
  // Initialize state
  ctx->current_state = CONN_STATE_IDLE;
  ctx->previous_state = CONN_STATE_IDLE;
 
  // Initialize timeout
  ctx->attempt_start_time_ns = time_get_realtime_ns();
  ctx->timeout_ns = CONN_TIMEOUT_TCP;
 
  // Initialize counters
  ctx->reconnect_attempt = 1;
  ctx->total_transitions = 0;
 
  log_debug("Connection context initialized");
 
  return ASCIICHAT_OK;
}

References connection_attempt_context_t::attempt_start_time_ns, CONN_STATE_IDLE, CONN_TIMEOUT_TCP, connection_attempt_context_t::current_state, connection_attempt_context_t::previous_state, connection_attempt_context_t::reconnect_attempt, time_get_realtime_ns(), connection_attempt_context_t::timeout_ns, and connection_attempt_context_t::total_transitions.

Referenced by client_main().

connection_state_name()

const char * connection_state_name

(

connection_state_t

state

)

Get human-readable state name for logging.

Parameters

state

Connection state

Returns

Static string representation (e.g., "DIRECT_TCP_CONNECTED")

Definition at line 50 of file connection_attempt.c.

                                                            {
  switch (state) {
  case CONN_STATE_IDLE:
    return "IDLE";
  case CONN_STATE_ATTEMPTING:
    return "ATTEMPTING";
  case CONN_STATE_CONNECTED:
    return "CONNECTED";
  case CONN_STATE_DISCONNECTED:
    return "DISCONNECTED";
  case CONN_STATE_FAILED:
    return "FAILED";
  default:
    return "UNKNOWN";
  }
}

References CONN_STATE_ATTEMPTING, CONN_STATE_CONNECTED, CONN_STATE_DISCONNECTED, CONN_STATE_FAILED, and CONN_STATE_IDLE.

Referenced by connection_state_transition().

connection_state_transition()

asciichat_error_t connection_state_transition	(	connection_attempt_context_t *	ctx,
		connection_state_t	new_state
	)

Transition to next connection state with validation.

Transition to next connection state.

Definition at line 134 of file connection_attempt.c.

                                                                                                               {
  if (!ctx) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Context pointer is NULL");
  }
 
  // Store previous state
  ctx->previous_state = ctx->current_state;
  ctx->current_state = new_state;
  ctx->total_transitions++;
 
  log_debug("State transition: %s → %s", connection_state_name(ctx->previous_state), connection_state_name(new_state));
 
  return ASCIICHAT_OK;
}

References connection_state_name(), connection_attempt_context_t::current_state, connection_attempt_context_t::previous_state, and connection_attempt_context_t::total_transitions.

Referenced by connection_attempt_tcp(), and connection_attempt_websocket().