Discovery session flow management. More...

Data Structures
struct	ring_consensus_t
	Ring consensus state (Host-Mediated Proactive Election) More...

struct	host_liveness_t
	Host liveness detection state. More...

struct	migration_ctx_t
	Host migration context for tracking failover state. More...

struct	discovery_session_t
	Discovery session context. More...

struct	discovery_config_t
	Configuration for discovery session. More...

Macros
#define	MAX_PARTICIPANTS 16

Typedefs
typedef bool(*	discovery_should_exit_fn) (void *user_data)
	Callback to check if session should exit.

Enumerations
enum	migration_state_t { MIGRATION_STATE_NONE , MIGRATION_STATE_DETECTED , MIGRATION_STATE_FAILOVER , MIGRATION_STATE_COMPLETE }
	Migration detection and failover state. More...

enum	discovery_state_t { DISCOVERY_STATE_INIT , DISCOVERY_STATE_CONNECTING_ACDS , DISCOVERY_STATE_CREATING_SESSION , DISCOVERY_STATE_JOINING_SESSION , DISCOVERY_STATE_WAITING_PEER , DISCOVERY_STATE_NEGOTIATING , DISCOVERY_STATE_STARTING_HOST , DISCOVERY_STATE_CONNECTING_HOST , DISCOVERY_STATE_ACTIVE , DISCOVERY_STATE_MIGRATING , DISCOVERY_STATE_FAILED , DISCOVERY_STATE_ENDED }
	Discovery session state. More...

Functions
discovery_session_t *	discovery_session_create (const discovery_config_t *config)
	Create a new discovery session.

void	discovery_session_destroy (discovery_session_t *session)
	Destroy discovery session and free resources.

asciichat_error_t	discovery_session_start (discovery_session_t *session)
	Start the discovery session.

asciichat_error_t	discovery_session_process (discovery_session_t *session, int64_t timeout_ns)
	Process session events (call in main loop)

void	discovery_session_stop (discovery_session_t *session)
	Stop the discovery session.

discovery_state_t	discovery_session_get_state (const discovery_session_t *session)
	Get current session state.

bool	discovery_session_is_active (const discovery_session_t *session)
	Check if session is active (call in progress)

const char *	discovery_session_get_string (const discovery_session_t *session)
	Get session string.

bool	discovery_session_is_host (const discovery_session_t *session)
	Check if we are the host.

session_host_t *	discovery_session_get_host (discovery_session_t *session)
	Get host context (if we are host)

session_participant_t *	discovery_session_get_participant (discovery_session_t *session)
	Get participant context (if we are participant)

asciichat_error_t	discovery_session_init_ring (discovery_session_t *session)
	Initialize ring consensus state.

asciichat_error_t	discovery_session_start_ring_round (discovery_session_t *session)
	Start a new ring consensus round (every 5 minutes or on new joiner)

asciichat_error_t	discovery_session_check_host_alive (discovery_session_t *session)
	Detect host disconnect (check connection status)

asciichat_error_t	discovery_session_handle_host_disconnect (discovery_session_t *session, uint32_t disconnect_reason)
	Handle host disconnect with automatic failover to future host.

asciichat_error_t	discovery_session_become_host (discovery_session_t *session)
	Become the host (called when elected as future host)

asciichat_error_t	discovery_session_connect_to_future_host (discovery_session_t *session)
	Connect to pre-elected future host (called when NOT future host)

asciichat_error_t	discovery_session_get_future_host (const discovery_session_t session, uint8_t out_id[16], char out_address[64], uint16_t out_port, uint8_t *out_connection_type)
	Get future host information.

bool	discovery_session_is_future_host (const discovery_session_t *session)
	Check if we are the future host.

Detailed Description

Discovery session flow management.

Manages the complete discovery session lifecycle:

Connect to ACDS
Create or join session
NAT negotiation (if needed)
Transition to host or participant role
Handle host migration

Definition in file session.h.

Macro Definition Documentation

◆ MAX_PARTICIPANTS

#define MAX_PARTICIPANTS 16

Definition at line 33 of file session.h.

Typedef Documentation

◆ discovery_should_exit_fn

typedef bool(* discovery_should_exit_fn) (void *user_data)

Callback to check if session should exit.

Called periodically during blocking operations (e.g., ACDS connect, join). Should return true to gracefully cancel the current operation.

Parameters

user_data Opaque pointer provided by caller

Returns: true to cancel operation, false to continue

Definition at line 111 of file session.h.

Enumeration Type Documentation

◆ discovery_state_t

enum discovery_state_t

Discovery session state.

Enumerator
DISCOVERY_STATE_INIT	Initial state.
DISCOVERY_STATE_CONNECTING_ACDS	Connecting to ACDS.
DISCOVERY_STATE_CREATING_SESSION	Creating new session.
DISCOVERY_STATE_JOINING_SESSION	Joining existing session.
DISCOVERY_STATE_WAITING_PEER	Waiting for peer to join (initiator)
DISCOVERY_STATE_NEGOTIATING	NAT negotiation in progress.
DISCOVERY_STATE_STARTING_HOST	Starting as host.
DISCOVERY_STATE_CONNECTING_HOST	Connecting to host as participant.
DISCOVERY_STATE_ACTIVE	Session active (call in progress)
DISCOVERY_STATE_MIGRATING	Host migration in progress.
DISCOVERY_STATE_FAILED	Session failed.
DISCOVERY_STATE_ENDED	Session ended.

Definition at line 116 of file session.h.

             {
  DISCOVERY_STATE_INIT,             
  DISCOVERY_STATE_CONNECTING_ACDS,  
  DISCOVERY_STATE_CREATING_SESSION, 
  DISCOVERY_STATE_JOINING_SESSION,  
  DISCOVERY_STATE_WAITING_PEER,     
  DISCOVERY_STATE_NEGOTIATING,      
  DISCOVERY_STATE_STARTING_HOST,    
  DISCOVERY_STATE_CONNECTING_HOST,  
  DISCOVERY_STATE_ACTIVE,           
  DISCOVERY_STATE_MIGRATING,        
  DISCOVERY_STATE_FAILED,           
  DISCOVERY_STATE_ENDED             
} discovery_state_t;

◆ migration_state_t

enum migration_state_t

Migration detection and failover state.

SIMPLIFIED DESIGN: No re-election during migration! Future host was pre-elected 5 minutes ago. When current host dies, we already know who takes over and where to find them.

Enumerator
MIGRATION_STATE_NONE	No migration in progress.
MIGRATION_STATE_DETECTED	Host disconnect detected.
MIGRATION_STATE_FAILOVER	Failing over to pre-elected future host.
MIGRATION_STATE_COMPLETE	Failover complete, call resumed.

Definition at line 85 of file session.h.

             {
  MIGRATION_STATE_NONE,     
  MIGRATION_STATE_DETECTED, 
  MIGRATION_STATE_FAILOVER, 
  MIGRATION_STATE_COMPLETE  
} migration_state_t;

Function Documentation

◆ discovery_session_become_host()

asciichat_error_t discovery_session_become_host ( discovery_session_t * session )

Become the host (called when elected as future host)

Parameters

session Session context

Returns: ASCIICHAT_OK on success

Definition at line 2080 of file src/discovery/session.c.

                                                                              {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  log_info("Starting as new host after migration (participant ID: %02x%02x...)", session->participant_id[0],
           session->participant_id[1]);
 
  // Get configured port (or use default)
  int host_port = GET_OPTION(port);
 
  // Mark ourselves as host
  session->is_host = true;
 
  // Create host context if needed with configured port
  if (!session->host_ctx) {
    session_host_config_t hconfig = {
        .port = host_port,
        .ipv4_address = "0.0.0.0",
        .max_clients = 32,
        .encryption_enabled = true,
    };
 
    session->host_ctx = session_host_create(&hconfig);
    if (!session->host_ctx) {
      log_error("Failed to create host context for migration");
      return ERROR_MEMORY;
    }
 
    // Start listening for new participant connections
    asciichat_error_t hstart = session_host_start(session->host_ctx);
    if (hstart != ASCIICHAT_OK) {
      log_error("Failed to start host after migration: %d", hstart);
      return hstart;
    }
 
    log_info("Host restarted after migration, listening on port %d", host_port);
  }
 
  // Send HOST_ANNOUNCEMENT to ACDS so other participants can reconnect
  acip_host_announcement_t announcement = {0};
  memcpy(announcement.session_id, session->session_id, 16);
  memcpy(announcement.host_id, session->participant_id, 16);
  SAFE_STRNCPY(announcement.host_address, "127.0.0.1", sizeof(announcement.host_address));
  // TODO: Use actual determined host address instead of 127.0.0.1
  announcement.host_port = host_port;
  announcement.connection_type = ACIP_CONNECTION_TYPE_DIRECT_PUBLIC;
  // TODO: Use actual connection type based on NAT quality
 
  if (session->acds_socket != INVALID_SOCKET_VALUE) {
    packet_send(session->acds_socket, PACKET_TYPE_ACIP_HOST_ANNOUNCEMENT, &announcement, sizeof(announcement));
    log_info("Sent HOST_ANNOUNCEMENT to ACDS for new host %02x%02x... at %s:%u", announcement.host_id[0],
             announcement.host_id[1], announcement.host_address, announcement.host_port);
  }
 
  // Mark migration complete
  session->migration.state = MIGRATION_STATE_COMPLETE;
 
  // Transition to ACTIVE state (host is ready)
  set_state(session, DISCOVERY_STATE_ACTIVE);
 
  return ASCIICHAT_OK;
}

References discovery_session_t::acds_socket, DISCOVERY_STATE_ACTIVE, discovery_session_t::host_ctx, discovery_session_t::is_host, discovery_session_t::migration, MIGRATION_STATE_COMPLETE, packet_send(), discovery_session_t::participant_id, session_host_create(), session_host_start(), discovery_session_t::session_id, and migration_ctx_t::state.

Referenced by discovery_session_handle_host_disconnect().

◆ discovery_session_check_host_alive()

asciichat_error_t discovery_session_check_host_alive ( discovery_session_t * session )

Detect host disconnect (check connection status)

Parameters

session Session context

Returns: ASCIICHAT_OK if host alive, error if disconnected

Definition at line 1957 of file src/discovery/session.c.

                                                                                   {
  if (!session || session->is_host) {
    // We are the host, so "host" is always alive
    return ASCIICHAT_OK;
  }
 
  // For WebRTC sessions, check the WebRTC transport instead of participant_ctx
  if (session->session_type == SESSION_TYPE_WEBRTC) {
    // If we have a WebRTC transport and it's marked as ready, host is alive
    if (session->webrtc_transport_ready) {
      return ASCIICHAT_OK;
    }
    // WebRTC transport not ready yet - might still be connecting
    return ERROR_NETWORK;
  }
 
  // For TCP sessions, check participant context
  // If we don't have a participant context yet, we're not connected
  if (!session->participant_ctx) {
    return ERROR_NETWORK;
  }
 
  // Check migration state - if we're already migrating, host is definitely not alive
  if (session->migration.state != MIGRATION_STATE_NONE) {
    return ERROR_NETWORK; // Already detected disconnect
  }
 
  uint64_t now_ms = session_get_current_time_ms();
 
  // Check if we have a ping in flight that timed out
  if (session->liveness.ping_in_flight) {
    uint64_t ping_age_ms = now_ms - session->liveness.last_ping_sent_ms;
    if (ping_age_ms > session->liveness.timeout_ms) {
      // Ping timed out
      session->liveness.consecutive_failures++;
      session->liveness.ping_in_flight = false;
      log_warn("Host ping timeout (attempt %u/%u, age=%llu ms)", session->liveness.consecutive_failures,
               session->liveness.max_failures, (unsigned long long)ping_age_ms);
 
      // Check if we've exceeded failure threshold
      if (session->liveness.consecutive_failures >= session->liveness.max_failures) {
        log_error("Host declared dead after %u consecutive ping failures", session->liveness.consecutive_failures);
        return ERROR_NETWORK;
      }
    }
  }
 
  // Check if it's time to send a new ping
  uint64_t time_since_last_ping = now_ms - session->liveness.last_ping_sent_ms;
  if (!session->liveness.ping_in_flight && time_since_last_ping >= session->liveness.ping_interval_ms) {
    // Send ping to host via participant connection
    socket_t host_socket = session_participant_get_socket(session->participant_ctx);
    if (host_socket != INVALID_SOCKET_VALUE) {
      asciichat_error_t result = packet_send(host_socket, PACKET_TYPE_PING, NULL, 0);
      if (result == ASCIICHAT_OK) {
        session->liveness.last_ping_sent_ms = now_ms;
        session->liveness.ping_in_flight = true;
        log_debug("Sent ping to host (attempt %u/%u)", session->liveness.consecutive_failures + 1,
                  session->liveness.max_failures);
      } else {
        log_warn("Failed to send ping to host: %d", result);
        session->liveness.consecutive_failures++;
        if (session->liveness.consecutive_failures >= session->liveness.max_failures) {
          log_error("Host declared dead after %u consecutive send failures", session->liveness.consecutive_failures);
          return ERROR_NETWORK;
        }
      }
    }
  }
 
  return ASCIICHAT_OK;
}

References host_liveness_t::consecutive_failures, discovery_session_t::is_host, host_liveness_t::last_ping_sent_ms, discovery_session_t::liveness, host_liveness_t::max_failures, discovery_session_t::migration, MIGRATION_STATE_NONE, packet_send(), discovery_session_t::participant_ctx, host_liveness_t::ping_in_flight, host_liveness_t::ping_interval_ms, session_participant_get_socket(), discovery_session_t::session_type, migration_ctx_t::state, host_liveness_t::timeout_ms, and discovery_session_t::webrtc_transport_ready.

Referenced by discovery_session_process().

◆ discovery_session_connect_to_future_host()

asciichat_error_t discovery_session_connect_to_future_host ( discovery_session_t * session )

Connect to pre-elected future host (called when NOT future host)

Parameters

session Session context

Returns: ASCIICHAT_OK on success

Definition at line 2145 of file src/discovery/session.c.

                                                                                         {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  log_info("Reconnecting to future host: %s:%u (connection type: %u)", session->ring.future_host_address,
           session->ring.future_host_port, session->ring.future_host_connection_type);
 
  // Destroy old participant context if present
  if (session->participant_ctx) {
    session_participant_destroy(session->participant_ctx);
    session->participant_ctx = NULL;
  }
 
  // Create new participant context for the future host
  session_participant_config_t pconfig = {
      .address = session->ring.future_host_address,
      .port = session->ring.future_host_port,
      .enable_audio = true,
      .enable_video = true,
      .encryption_enabled = true,
  };
 
  session->participant_ctx = session_participant_create(&pconfig);
  if (!session->participant_ctx) {
    log_error("Failed to create participant context for future host");
    return ERROR_MEMORY;
  }
 
  // Attempt connection to future host
  asciichat_error_t pconn = session_participant_connect(session->participant_ctx);
  if (pconn != ASCIICHAT_OK) {
    log_error("Failed to connect to future host: %d", pconn);
    return pconn;
  }
 
  log_info("Connected to future host after migration");
 
  // Update our host info with the new future host details
  memcpy(session->host_id, session->ring.future_host_id, 16);
  SAFE_STRNCPY(session->host_address, session->ring.future_host_address, sizeof(session->host_address));
  session->host_port = session->ring.future_host_port;
 
  log_info("Updated host info to: %s:%u (id: %02x%02x...)", session->host_address, session->host_port,
           session->host_id[0], session->host_id[1]);
 
  // Mark migration complete (in real implementation, this would be done after successful connection)
  session->migration.state = MIGRATION_STATE_COMPLETE;
 
  // Transition to ACTIVE state (participant is ready)
  set_state(session, DISCOVERY_STATE_ACTIVE);
 
  return ASCIICHAT_OK;
}

References session_participant::address, DISCOVERY_STATE_ACTIVE, ring_consensus_t::future_host_address, ring_consensus_t::future_host_connection_type, ring_consensus_t::future_host_id, ring_consensus_t::future_host_port, discovery_session_t::host_address, discovery_session_t::host_id, discovery_session_t::host_port, discovery_session_t::migration, MIGRATION_STATE_COMPLETE, discovery_session_t::participant_ctx, discovery_session_t::ring, session_participant_connect(), session_participant_create(), session_participant_destroy(), and migration_ctx_t::state.

Referenced by discovery_session_handle_host_disconnect().

◆ discovery_session_create()

discovery_session_t * discovery_session_create ( const discovery_config_t * config )

Create a new discovery session.

Parameters

config Session configuration

Returns: New session or NULL on error

Definition at line 48 of file src/discovery/session.c.

                                                                                {
  if (!config) {
    SET_ERRNO(ERROR_INVALID_PARAM, "config is NULL");
    return NULL;
  }
 
  discovery_session_t *session = SAFE_CALLOC(1, sizeof(discovery_session_t), discovery_session_t *);
  if (!session) {
    SET_ERRNO(ERROR_MEMORY, "Failed to allocate discovery session");
    return NULL;
  }
 
  session->state = DISCOVERY_STATE_INIT;
  session->acds_socket = INVALID_SOCKET_VALUE;
  session->peer_manager = NULL;
  session->webrtc_transport_ready = false;
  session->webrtc_connection_initiated = false;
  session->webrtc_retry_attempt = 0;
  session->webrtc_last_attempt_time_ms = 0;
  session->stun_servers = NULL;
  session->stun_count = 0;
  session->turn_servers = NULL;
  session->turn_count = 0;
 
  // Initialize host liveness detection
  session->liveness.last_ping_sent_ms = 0;
  session->liveness.last_pong_received_ms = 0;
  session->liveness.consecutive_failures = 0;
  session->liveness.max_failures = 3;
  session->liveness.ping_interval_ms = 3 * MS_PER_SEC_INT; // Ping every 3 seconds
  session->liveness.timeout_ms = 10 * MS_PER_SEC_INT;      // 10 second timeout
  session->liveness.ping_in_flight = false;
 
  log_info("discovery_session_create: After CALLOC - participant_ctx=%p, host_ctx=%p", session->participant_ctx,
           session->host_ctx);
 
  // Load or generate identity key
  char identity_path[256];
  asciichat_error_t id_result = acds_identity_default_path(identity_path, sizeof(identity_path));
  if (id_result == ASCIICHAT_OK) {
    id_result = acds_identity_load(identity_path, session->identity_pubkey, session->identity_seckey);
    if (id_result != ASCIICHAT_OK) {
      // File doesn't exist or is corrupted - generate new key
      log_info("Identity key not found, generating new key");
      id_result = acds_identity_generate(session->identity_pubkey, session->identity_seckey);
      if (id_result == ASCIICHAT_OK) {
        // Save for future use
        acds_identity_save(identity_path, session->identity_pubkey, session->identity_seckey);
      }
    }
  }
 
  if (id_result != ASCIICHAT_OK) {
    log_warn("Failed to load/generate identity key, using zero key");
    memset(session->identity_pubkey, 0, sizeof(session->identity_pubkey));
    memset(session->identity_seckey, 0, sizeof(session->identity_seckey));
  } else {
    char fingerprint[65];
    acds_identity_fingerprint(session->identity_pubkey, fingerprint);
    log_info("Using identity key with fingerprint: %.16s...", fingerprint);
  }
 
  // ACDS connection info
  if (config->acds_address && config->acds_address[0]) {
    SAFE_STRNCPY(session->acds_address, config->acds_address, sizeof(session->acds_address));
  } else {
    SAFE_STRNCPY(session->acds_address, "127.0.0.1", sizeof(session->acds_address));
  }
  session->acds_port = config->acds_port > 0 ? config->acds_port : ACIP_DISCOVERY_DEFAULT_PORT;
 
  // Session string (if joining)
  if (config->session_string && config->session_string[0]) {
    SAFE_STRNCPY(session->session_string, config->session_string, sizeof(session->session_string));
    session->is_initiator = false;
  } else {
    session->is_initiator = true;
  }
 
  // Callbacks
  session->on_state_change = config->on_state_change;
  session->on_session_ready = config->on_session_ready;
  session->on_error = config->on_error;
  session->callback_user_data = config->callback_user_data;
  session->should_exit_callback = config->should_exit_callback;
  session->exit_callback_data = config->exit_callback_data;
 
  log_debug("Discovery session created (initiator=%d, acds=%s:%u)", session->is_initiator, session->acds_address,
            session->acds_port);
 
  return session;
}

Referenced by discovery_main().

◆ discovery_session_destroy()

void discovery_session_destroy ( discovery_session_t * session )

Destroy discovery session and free resources.

Parameters

session Session to destroy

Definition at line 140 of file src/discovery/session.c.

                                                             {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return;
  }
 
  // Close ACDS connection
  if (session->acds_socket != INVALID_SOCKET_VALUE) {
    socket_close(session->acds_socket);
    session->acds_socket = INVALID_SOCKET_VALUE;
  }
 
  // Destroy host context if active
  if (session->host_ctx) {
    session_host_destroy(session->host_ctx);
    session->host_ctx = NULL;
  }
 
  // Destroy participant context if active
  if (session->participant_ctx) {
    session_participant_destroy(session->participant_ctx);
    session->participant_ctx = NULL;
  }
 
  // Clean up WebRTC peer manager (NEW)
  if (session->peer_manager) {
    webrtc_peer_manager_destroy(session->peer_manager);
    session->peer_manager = NULL;
  }
 
  // Clean up STUN/TURN server arrays (NEW)
  if (session->stun_servers) {
    SAFE_FREE(session->stun_servers);
    session->stun_servers = NULL;
    session->stun_count = 0;
  }
 
  if (session->turn_servers) {
    SAFE_FREE(session->turn_servers);
    session->turn_servers = NULL;
    session->turn_count = 0;
  }
 
  SAFE_FREE(session);
}

References discovery_session_t::acds_socket, discovery_session_t::host_ctx, discovery_session_t::participant_ctx, discovery_session_t::peer_manager, session_host_destroy(), session_participant_destroy(), discovery_session_t::stun_count, discovery_session_t::stun_servers, discovery_session_t::turn_count, discovery_session_t::turn_servers, and webrtc_peer_manager_destroy().

Referenced by discovery_main().

◆ discovery_session_get_future_host()

asciichat_error_t discovery_session_get_future_host	(	const discovery_session_t *	session,
		uint8_t	out_id[16],
		char	out_address[64],
		uint16_t *	out_port,
		uint8_t *	out_connection_type
	)

Get future host information.

Parameters

session	Session context
out_id	Output: Future host participant ID
out_address	Output: Future host address
out_port	Output: Future host port
out_connection_type	Output: Connection type

Returns: ASCIICHAT_OK if future host known, error otherwise

Definition at line 2201 of file src/discovery/session.c.

                                                                                  {
  if (!session || !out_id || !out_address || !out_port || !out_connection_type) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid output parameters");
    return ERROR_INVALID_PARAM;
  }
 
  if (session->ring.future_host_id[0] == 0) {
    SET_ERRNO(ERROR_NOT_FOUND, "Future host not elected yet");
    return ERROR_NOT_FOUND;
  }
 
  memcpy(out_id, session->ring.future_host_id, 16);
  SAFE_STRNCPY(out_address, session->ring.future_host_address, 64);
  *out_port = session->ring.future_host_port;
  *out_connection_type = session->ring.future_host_connection_type;
 
  return ASCIICHAT_OK;
}

References ring_consensus_t::future_host_address, ring_consensus_t::future_host_connection_type, ring_consensus_t::future_host_id, ring_consensus_t::future_host_port, and discovery_session_t::ring.

◆ discovery_session_get_host()

session_host_t * discovery_session_get_host ( discovery_session_t * session )

Get host context (if we are host)

Parameters

session Session context

Returns: Host context or NULL

Definition at line 1805 of file src/discovery/session.c.

                                                                         {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null session");
    return NULL;
  }
  return session->host_ctx;
}

References discovery_session_t::host_ctx.

◆ discovery_session_get_participant()

session_participant_t * discovery_session_get_participant ( discovery_session_t * session )

Get participant context (if we are participant)

Parameters

session Session context

Returns: Participant context or NULL

Definition at line 1813 of file src/discovery/session.c.

                                                                                       {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null session");
    return NULL;
  }
  return session->participant_ctx;
}

References discovery_session_t::participant_ctx.

◆ discovery_session_get_state()

discovery_state_t discovery_session_get_state ( const discovery_session_t * session )

Get current session state.

Parameters

session Session context

Returns: Current state

Definition at line 1773 of file src/discovery/session.c.

                                                                                  {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null session");
    return DISCOVERY_STATE_FAILED;
  }
  return session->state;
}

References DISCOVERY_STATE_FAILED, and discovery_session_t::state.

◆ discovery_session_get_string()

const char * discovery_session_get_string ( const discovery_session_t * session )

Get session string.

Parameters

session Session context

Returns: Session string or NULL if not yet assigned

Definition at line 1789 of file src/discovery/session.c.

                                                                             {
  if (!session || session->session_string[0] == '\0') {
    SET_ERRNO(ERROR_INVALID_PARAM, "null session or session string is empty");
    return NULL;
  }
  return session->session_string;
}

References discovery_session_t::session_string.

◆ discovery_session_handle_host_disconnect()

asciichat_error_t discovery_session_handle_host_disconnect	(	discovery_session_t *	session,
		uint32_t	disconnect_reason
	)

Handle host disconnect with automatic failover to future host.

Parameters

session	Session context
disconnect_reason	Reason code for disconnect

Returns: ASCIICHAT_OK on successful failover

Definition at line 2030 of file src/discovery/session.c.

                                                                                                                     {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  log_warn("Host disconnect detected: reason=%u", disconnect_reason);
 
  // Initialize migration context
  session->migration.state = MIGRATION_STATE_DETECTED;
  session->migration.detection_time_ms = session_get_current_time_ms();
  memcpy(session->migration.last_host_id, session->host_id, 16);
  session->migration.disconnect_reason = disconnect_reason;
 
  // Notify ACDS of host loss (lightweight notification, no NAT data exchanged!)
  acip_host_lost_t host_lost = {0};
  memcpy(host_lost.session_id, session->session_id, 16);
  memcpy(host_lost.participant_id, session->participant_id, 16);
  memcpy(host_lost.last_host_id, session->host_id, 16);
  host_lost.disconnect_reason = disconnect_reason;
  host_lost.disconnect_time_ms = session->migration.detection_time_ms;
 
  packet_send(session->acds_socket, PACKET_TYPE_ACIP_HOST_LOST, &host_lost, sizeof(host_lost));
 
  // Check if we have a pre-elected future host (from last 5-minute ring round)
  if (session->ring.future_host_id[0] == 0) {
    // No future host known! This shouldn't happen if we just received FUTURE_HOST_ELECTED
    // within the last 5 minutes. Fall back to treating this as fatal.
    log_error("No future host pre-elected! Session cannot recover from host disconnect.");
    session->migration.state = MIGRATION_STATE_COMPLETE;
    return ERROR_NETWORK; // Session should end
  }
 
  // **SIMPLIFIED**: No metrics exchange needed! Future host was already elected 5 minutes ago.
  // Just failover to the pre-elected host.
  session->migration.state = MIGRATION_STATE_FAILOVER;
 
  // Check if I am the future host
  if (session->ring.am_future_host) {
    // I become the new host immediately! (no election delay!)
    log_info("Becoming host (I'm the pre-elected future host)");
    return discovery_session_become_host(session);
  } else {
    // Connect to pre-elected future host (address already stored!)
    log_info("Connecting to pre-elected future host: %s:%u", session->ring.future_host_address,
             session->ring.future_host_port);
    return discovery_session_connect_to_future_host(session);
  }
}

References discovery_session_t::acds_socket, ring_consensus_t::am_future_host, migration_ctx_t::detection_time_ms, migration_ctx_t::disconnect_reason, discovery_session_become_host(), discovery_session_connect_to_future_host(), ring_consensus_t::future_host_address, ring_consensus_t::future_host_id, ring_consensus_t::future_host_port, discovery_session_t::host_id, migration_ctx_t::last_host_id, discovery_session_t::migration, MIGRATION_STATE_COMPLETE, MIGRATION_STATE_DETECTED, MIGRATION_STATE_FAILOVER, packet_send(), discovery_session_t::participant_id, discovery_session_t::ring, discovery_session_t::session_id, and migration_ctx_t::state.

Referenced by discovery_session_process().

◆ discovery_session_init_ring()

asciichat_error_t discovery_session_init_ring ( discovery_session_t * session )

Initialize ring consensus state.

Simplified for host-mediated architecture - just initializes timing, no participant list needed (host runs the election).

Parameters

session Session context

Returns: ASCIICHAT_OK on success

Definition at line 1912 of file src/discovery/session.c.

                                                                            {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  // Simplified for new architecture: just initialize timing
  // No participant list needed - host runs the election
  session->ring.last_ring_round_ms = session_get_current_time_ms();
  session->ring.am_future_host = false;
  memset(session->ring.future_host_id, 0, 16);
 
  log_info("Ring consensus initialized (host-mediated model)");
  return ASCIICHAT_OK;
}

References ring_consensus_t::am_future_host, ring_consensus_t::future_host_id, ring_consensus_t::last_ring_round_ms, and discovery_session_t::ring.

◆ discovery_session_is_active()

bool discovery_session_is_active ( const discovery_session_t * session )

Check if session is active (call in progress)

Parameters

session Session context

Returns: True if active

Definition at line 1781 of file src/discovery/session.c.

                                                                     {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null session");
    return false;
  }
  return session->state == DISCOVERY_STATE_ACTIVE;
}

References DISCOVERY_STATE_ACTIVE, and discovery_session_t::state.

◆ discovery_session_is_future_host()

bool discovery_session_is_future_host ( const discovery_session_t * session )

Check if we are the future host.

Parameters

session Session context

Returns: True if we will be host if current host dies

Definition at line 2222 of file src/discovery/session.c.

                                                                          {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null session");
    return false;
  }
  return session->ring.am_future_host;
}

References ring_consensus_t::am_future_host, and discovery_session_t::ring.

◆ discovery_session_is_host()

bool discovery_session_is_host ( const discovery_session_t * session )

Check if we are the host.

Parameters

session Session context

Returns: True if we are hosting

Definition at line 1797 of file src/discovery/session.c.

                                                                   {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "null session");
    return false;
  }
  return session->is_host;
}

References discovery_session_t::is_host.

◆ discovery_session_process()

asciichat_error_t discovery_session_process	(	discovery_session_t *	session,
		int64_t	timeout_ns
	)

Process session events (call in main loop)

Handles incoming ACDS messages, negotiation, and state transitions.

Parameters

session	Session context
timeout_ns	Max time to wait for events in nanoseconds (0 = non-blocking)

Returns: ASCIICHAT_OK on success, error on failure

Definition at line 1256 of file src/discovery/session.c.

                                                                                              {
  if (!session) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
  }
 
  // Handle state-specific processing
  switch (session->state) {
  case DISCOVERY_STATE_WAITING_PEER: {
    // Wait for PARTICIPANT_JOINED notification from ACDS
    if (session->acds_socket != INVALID_SOCKET_VALUE && timeout_ns > 0) {
      // Set socket timeout
      if (socket_set_timeout(session->acds_socket, timeout_ns) == 0) {
        packet_type_t type;
        void *data = NULL;
        size_t len = 0;
 
        // Try to receive a packet (non-blocking with timeout)
        asciichat_error_t recv_result = packet_receive(session->acds_socket, &type, &data, &len);
        if (recv_result == ASCIICHAT_OK) {
          if (type == PACKET_TYPE_ACIP_PARTICIPANT_JOINED) {
            log_info("Peer joined session, transitioning to negotiation");
            set_state(session, DISCOVERY_STATE_NEGOTIATING);
            POOL_FREE(data, len);
          } else {
            // Got some other packet, handle it or ignore
            log_debug("Received packet type %d while waiting for peer", type);
            POOL_FREE(data, len);
          }
        } else if (recv_result == ERROR_NETWORK_TIMEOUT) {
          // Timeout is normal, just return
        } else {
          log_debug("Packet receive error while waiting for peer: %d", recv_result);
        }
      }
    } else {
      // Fallback to sleep if no timeout or invalid socket
      platform_sleep_us(timeout_ns / 1000);
    }
    break;
  }
 
  case DISCOVERY_STATE_NEGOTIATING: {
    // Handle NAT negotiation
    if (session->negotiate.state == NEGOTIATE_STATE_INIT) {
      // Initialize negotiation
      negotiate_init(&session->negotiate, session->session_id, session->participant_id, session->is_initiator);
      log_info("Starting NAT negotiation (initiator=%d)", session->is_initiator);
 
      // Send our NETWORK_QUALITY to ACDS immediately (let peer receive it)
      asciichat_error_t send_result = send_network_quality_to_acds(session);
      if (send_result != ASCIICHAT_OK) {
        log_warn("Failed to send initial NETWORK_QUALITY: %d", send_result);
        // Don't fail - we'll try again next iteration
      }
    }
 
    // Try to receive peer's NETWORK_QUALITY from ACDS (non-blocking with short timeout)
    if (!session->negotiate.peer_quality_received) {
      asciichat_error_t recv_result = receive_network_quality_from_acds(session);
      if (recv_result == ASCIICHAT_OK) {
        // Got peer quality - proceed to election
        log_info("Received peer NETWORK_QUALITY, proceeding to host election");
      } else if (recv_result != ERROR_NETWORK_TIMEOUT) {
        // Real error (not just timeout)
        log_debug("Error receiving NETWORK_QUALITY: %d (this might be normal if peer not ready)", recv_result);
      }
    }
 
    // Check if we have both qualities and can determine host
    if (session->negotiate.peer_quality_received && session->negotiate.state != NEGOTIATE_STATE_COMPARING) {
      // Both sides have exchanged NAT quality - determine the winner
      log_info("Both NAT qualities received, determining host...");
      asciichat_error_t result = negotiate_determine_result(&session->negotiate);
      if (result == ASCIICHAT_OK) {
        // Store result
        session->is_host = session->negotiate.we_are_host;
 
        if (session->is_host) {
          // We won the negotiation - become the host
          log_info("🏠 NAT negotiation complete: WE ARE HOST (tier:%d vs tier:%d)",
                   nat_compute_tier(&session->negotiate.our_quality),
                   nat_compute_tier(&session->negotiate.peer_quality));
          memcpy(session->host_id, session->participant_id, 16);
          SAFE_STRNCPY(session->host_address, session->negotiate.host_address, sizeof(session->host_address));
          session->host_port = session->negotiate.host_port;
          set_state(session, DISCOVERY_STATE_STARTING_HOST);
        } else {
          // They won - we'll be a participant
          log_info("👤 NAT negotiation complete: THEY ARE HOST at %s:%u (tier:%d vs tier:%d)",
                   session->negotiate.host_address, session->negotiate.host_port,
                   nat_compute_tier(&session->negotiate.our_quality),
                   nat_compute_tier(&session->negotiate.peer_quality));
          SAFE_STRNCPY(session->host_address, session->negotiate.host_address, sizeof(session->host_address));
          session->host_port = session->negotiate.host_port;
          set_state(session, DISCOVERY_STATE_CONNECTING_HOST);
        }
      } else {
        log_error("Failed to determine negotiation result: %d", result);
        set_error(session, result, "Host election failed");
      }
    } else {
      // Still waiting for peer quality - sleep briefly to avoid busy loop
      platform_sleep_us(timeout_ns / 1000);
    }
    break;
  }
 
  case DISCOVERY_STATE_STARTING_HOST: {
    // Start hosting
    if (!session->host_ctx) {
      // Create host context with configured port
      int host_port = GET_OPTION(port);
 
      session_host_config_t hconfig = {
          .port = host_port,
          .ipv4_address = "0.0.0.0",
          .max_clients = 32,
          .encryption_enabled = true,
      };
 
      session->host_ctx = session_host_create(&hconfig);
      if (!session->host_ctx) {
        log_error("Failed to create host context");
        set_error(session, ERROR_MEMORY, "Failed to create host context");
        break;
      }
 
      // Start listening
      asciichat_error_t hstart = session_host_start(session->host_ctx);
      if (hstart != ASCIICHAT_OK) {
        log_error("Failed to start host: %d", hstart);
        set_error(session, hstart, "Failed to start host");
        break;
      }
 
      log_info("Host started, listening for connections");
    }
 
    // Notify listeners that we're ready
    if (session->on_session_ready) {
      session->on_session_ready(session->session_string, session->callback_user_data);
    }
 
    set_state(session, DISCOVERY_STATE_ACTIVE);
    break;
  }
 
  case DISCOVERY_STATE_CONNECTING_HOST: {
    // Connect to host as participant
 
    // For WebRTC sessions, wait for DataChannel to open
    if (session->session_type == SESSION_TYPE_WEBRTC) {
      // Check if transport is ready (DataChannel opened)
      if (session->webrtc_transport_ready) {
        log_info("WebRTC DataChannel established, transitioning to ACTIVE state");
        set_state(session, DISCOVERY_STATE_ACTIVE);
        break;
      }
 
      // If not ready and we haven't initiated connection yet, initiate it
      if (session->peer_manager && !session->webrtc_connection_initiated) {
        log_info("Initiating WebRTC connection to host (attempt %d/%d)...", session->webrtc_retry_attempt + 1,
                 GET_OPTION(webrtc_reconnect_attempts) + 1);
 
        // Initiate connection (generates offer, triggers SDP exchange)
        asciichat_error_t conn_result =
            webrtc_peer_manager_connect(session->peer_manager, session->session_id, session->host_id);
 
        if (conn_result != ASCIICHAT_OK) {
          log_error("Failed to initiate WebRTC connection: %d", conn_result);
          set_error(session, conn_result, "Failed to initiate WebRTC connection");
          break;
        }
 
        log_info("WebRTC connection initiated, waiting for DataChannel...");
        session->webrtc_connection_initiated = true;
        session->webrtc_last_attempt_time_ms = platform_get_monotonic_time_us() / 1000;
      }
 
      // Check for ICE gathering timeout on all peers
      if (session->webrtc_connection_initiated && session->peer_manager) {
        int timeout_ms = GET_OPTION(webrtc_ice_timeout_ms);
        int timed_out_count = webrtc_peer_manager_check_gathering_timeouts(session->peer_manager, timeout_ms);
 
        if (timed_out_count > 0) {
          log_error("ICE gathering timeout: %d peer(s) failed to gather candidates within %dms", timed_out_count,
                    timeout_ms);
 
          // Check if we have retries remaining
          int max_attempts = GET_OPTION(webrtc_reconnect_attempts);
          if (session->webrtc_retry_attempt < max_attempts) {
            // Calculate exponential backoff delay
            uint32_t backoff_ms = calculate_backoff_delay_ms(session->webrtc_retry_attempt);
 
            log_warn("WebRTC connection attempt %d/%d failed, retrying in %ums...", session->webrtc_retry_attempt + 1,
                     max_attempts + 1, backoff_ms);
 
            // Wait for backoff period
            platform_sleep_ms(backoff_ms);
 
            // Destroy old peer manager
            webrtc_peer_manager_destroy(session->peer_manager);
            session->peer_manager = NULL;
 
            // Re-initialize peer manager for retry
            asciichat_error_t reinit_result = initialize_webrtc_peer_manager(session);
            if (reinit_result != ASCIICHAT_OK) {
              log_error("Failed to re-initialize WebRTC for retry: %d", reinit_result);
              set_error(session, reinit_result, "Failed to re-initialize WebRTC for retry");
 
              // If --prefer-webrtc is set, this is a fatal error
              if (GET_OPTION(prefer_webrtc)) {
                log_fatal("WebRTC connection failed and --prefer-webrtc is set - exiting");
                set_state(session, DISCOVERY_STATE_FAILED);
                return ERROR_NETWORK_TIMEOUT;
              }
 
              break; // Exit this case to allow fallback to TCP
            }
 
            // Reset connection state for retry
            session->webrtc_connection_initiated = false;
            session->webrtc_retry_attempt++;
 
            log_info("WebRTC peer manager re-initialized for attempt %d/%d", session->webrtc_retry_attempt + 1,
                     max_attempts + 1);
          } else {
            // No more retries - connection failed
            log_error("WebRTC connection failed after %d attempts (timeout: %dms)", max_attempts + 1, timeout_ms);
 
            // Set error state - WebRTC connection failed
            char error_msg[256];
            snprintf(error_msg, sizeof(error_msg), "WebRTC connection failed after %d attempts (%dms timeout)",
                     max_attempts + 1, timeout_ms);
            set_error(session, ERROR_NETWORK_TIMEOUT, error_msg);
 
            // If --prefer-webrtc is set, this is a fatal error (no TCP fallback)
            if (GET_OPTION(prefer_webrtc)) {
              log_fatal("WebRTC connection failed and --prefer-webrtc is set - exiting");
              set_state(session, DISCOVERY_STATE_FAILED);
              return ERROR_NETWORK_TIMEOUT;
            }
 
            break; // Exit this case to allow fallback to TCP
          }
        }
      }
 
      // Poll ACDS for WebRTC signaling messages (SDP answer, ICE candidates)
      // while waiting for DataChannel to open
      if (session->acds_socket != INVALID_SOCKET_VALUE) {
        // Check if data available (non-blocking with timeout_ns)
        struct timeval tv_timeout;
        tv_timeout.tv_sec = timeout_ns / NS_PER_SEC_INT;
        tv_timeout.tv_usec = (timeout_ns % NS_PER_SEC_INT) / 1000;
 
        fd_set readfds;
        FD_ZERO(&readfds);
        FD_SET(session->acds_socket, &readfds);
 
        int select_result = select(session->acds_socket + 1, &readfds, NULL, NULL, &tv_timeout);
        if (select_result > 0 && FD_ISSET(session->acds_socket, &readfds)) {
          // Data available to read
          packet_type_t type;
          void *data = NULL;
          size_t len = 0;
 
          asciichat_error_t recv_result = packet_receive(session->acds_socket, &type, &data, &len);
 
          if (recv_result == ASCIICHAT_OK) {
            // Dispatch to appropriate handler
            handle_acds_webrtc_packet(session, type, data, len);
            POOL_FREE(data, len);
          } else {
            log_debug("Failed to receive ACDS packet: %d", recv_result);
          }
        }
      }
 
      // Stay in CONNECTING_HOST until DataChannel opens (webrtc_transport_ready becomes true)
      // The discovery_on_transport_ready callback will set webrtc_transport_ready=true
      break;
    }
 
    if (!session->participant_ctx) {
      // Create participant context for this session
      session_participant_config_t pconfig = {
          .address = session->host_address,
          .port = session->host_port,
          .enable_audio = true,
          .enable_video = true,
          .encryption_enabled = true,
      };
 
      session->participant_ctx = session_participant_create(&pconfig);
      if (!session->participant_ctx) {
        log_error("Failed to create participant context");
        set_error(session, ERROR_MEMORY, "Failed to create participant context");
        break;
      }
 
      // Attempt connection
      asciichat_error_t pconn = session_participant_connect(session->participant_ctx);
      if (pconn != ASCIICHAT_OK) {
        log_error("Failed to connect as participant: %d", pconn);
        // Stay in this state, will retry on next process() call
        break;
      }
 
      log_info("Connected to host, performing crypto handshake...");
 
      // Perform crypto handshake with server
      // Get the socket from participant context
      socket_t participant_socket = session_participant_get_socket(session->participant_ctx);
      if (participant_socket == INVALID_SOCKET_VALUE) {
        log_error("Failed to get socket from participant context");
        set_error(session, ERROR_NETWORK, "Failed to get participant socket");
        session_participant_disconnect(session->participant_ctx);
        break;
      }
 
      // Step 1: Send client protocol version
      log_debug("Sending protocol version to server...");
      protocol_version_packet_t client_version = {0};
      client_version.protocol_version = HOST_TO_NET_U16(1);  // Protocol version 1
      client_version.protocol_revision = HOST_TO_NET_U16(0); // Revision 0
      client_version.supports_encryption = 1;                // We support encryption
      client_version.compression_algorithms = 0;
      client_version.compression_threshold = 0;
      client_version.feature_flags = 0;
 
      int result = send_protocol_version_packet(participant_socket, &client_version);
      if (result != 0) {
        log_error("Failed to send protocol version to server");
        set_error(session, ERROR_NETWORK, "Failed to send protocol version");
        session_participant_disconnect(session->participant_ctx);
        break;
      }
 
      // Step 2: Receive server protocol version
      log_debug("Receiving server protocol version...");
      packet_type_t packet_type;
      void *payload = NULL;
      size_t payload_len = 0;
 
      int recv_result = receive_packet(participant_socket, &packet_type, &payload, &payload_len);
      if (recv_result != ASCIICHAT_OK || packet_type != PACKET_TYPE_PROTOCOL_VERSION) {
        log_error("Failed to receive server protocol version (got type 0x%x)", packet_type);
        if (payload) {
          buffer_pool_free(NULL, payload, payload_len);
        }
        set_error(session, ERROR_NETWORK, "Failed to receive protocol version from server");
        session_participant_disconnect(session->participant_ctx);
        break;
      }
 
      if (payload_len != sizeof(protocol_version_packet_t)) {
        log_error("Invalid protocol version packet size: %zu", payload_len);
        buffer_pool_free(NULL, payload, payload_len);
        set_error(session, ERROR_NETWORK, "Invalid protocol version packet");
        session_participant_disconnect(session->participant_ctx);
        break;
      }
 
      protocol_version_packet_t server_version;
      memcpy(&server_version, payload, sizeof(protocol_version_packet_t));
      buffer_pool_free(NULL, payload, payload_len);
 
      if (!server_version.supports_encryption) {
        log_error("Server does not support encryption");
        set_error(session, ERROR_NETWORK, "Server does not support encryption");
        session_participant_disconnect(session->participant_ctx);
        break;
      }
 
      log_info("Server protocol version: %u.%u (encryption: yes)", NET_TO_HOST_U16(server_version.protocol_version),
               NET_TO_HOST_U16(server_version.protocol_revision));
 
      // Step 3: Send crypto capabilities
      log_debug("Sending crypto capabilities...");
      crypto_capabilities_packet_t client_caps = {0};
      client_caps.supported_kex_algorithms = HOST_TO_NET_U16(0x0001);    // KEX_ALGO_X25519
      client_caps.supported_auth_algorithms = HOST_TO_NET_U16(0x0003);   // AUTH_ALGO_ED25519 | AUTH_ALGO_NONE
      client_caps.supported_cipher_algorithms = HOST_TO_NET_U16(0x0001); // CIPHER_ALGO_XSALSA20_POLY1305
      client_caps.requires_verification = 0;
      client_caps.preferred_kex = 0x0001;    // KEX_ALGO_X25519
      client_caps.preferred_auth = 0x0001;   // AUTH_ALGO_ED25519
      client_caps.preferred_cipher = 0x0001; // CIPHER_ALGO_XSALSA20_POLY1305
 
      result = send_crypto_capabilities_packet(participant_socket, &client_caps);
      if (result != 0) {
        log_error("Failed to send crypto capabilities");
        set_error(session, ERROR_NETWORK, "Failed to send crypto capabilities");
        session_participant_disconnect(session->participant_ctx);
        break;
      }
 
      log_info("Crypto handshake initiated successfully");
      log_warn("*** Connected to host as participant - transitioning to ACTIVE ***");
    }
 
    // Check if connection is established
    bool ctx_valid = session->participant_ctx != NULL;
    bool is_connected = ctx_valid ? session_participant_is_connected(session->participant_ctx) : false;
    log_debug("discovery_session_process: CONNECTING_HOST - participant_ctx=%p, ctx_valid=%d, is_connected=%d",
              session->participant_ctx, ctx_valid, is_connected);
 
    if (ctx_valid && !is_connected) {
      // Log more details about why it's not connected
      log_debug("discovery_session_process: CONNECTING_HOST - context exists but not connected yet");
    }
 
    if (is_connected) {
      log_info("Participant connection confirmed, transitioning to ACTIVE state");
      set_state(session, DISCOVERY_STATE_ACTIVE);
    } else {
      log_debug("discovery_session_process: CONNECTING_HOST - awaiting connection establishment (ctx_valid=%d, "
                "is_connected=%d)",
                ctx_valid, is_connected);
    }
    break;
  }
 
  case DISCOVERY_STATE_ACTIVE:
    // Receive and handle ACDS packets for WebRTC signaling (NEW)
    if (session->session_type == SESSION_TYPE_WEBRTC && session->acds_socket != INVALID_SOCKET_VALUE) {
      // Use non-blocking polling to check for incoming ACDS packets
      struct pollfd pfd = {.fd = session->acds_socket, .events = POLLIN, .revents = 0};
 
      int poll_result = socket_poll(&pfd, 1, 0); // Non-blocking poll (timeout=0)
 
      if (poll_result > 0 && (pfd.revents & POLLIN)) {
        // Data available to read
        packet_type_t type;
        void *data = NULL;
        size_t len = 0;
 
        asciichat_error_t recv_result = packet_receive(session->acds_socket, &type, &data, &len);
 
        if (recv_result == ASCIICHAT_OK) {
          // Dispatch to appropriate handler
          handle_acds_webrtc_packet(session, type, data, len);
          POOL_FREE(data, len);
        }
      }
    }
 
    // Session is active - check for host disconnect
    if (!session->is_host) {
      // We are a participant - check if host is still alive
      asciichat_error_t host_check = discovery_session_check_host_alive(session);
      if (host_check != ASCIICHAT_OK) {
        // Host is down! Trigger automatic failover to pre-elected future host
        log_warn("Host disconnect detected during ACTIVE state");
 
        // If --prefer-webrtc is set, WebRTC failure is fatal (no TCP fallback)
        const options_t *opts = options_get();
        if (opts && opts->prefer_webrtc) {
          log_fatal("WebRTC connection failed and --prefer-webrtc is set - exiting");
          set_state(session, DISCOVERY_STATE_FAILED);
          session->error = ERROR_NETWORK;
          return ERROR_NETWORK;
        }
 
        set_state(session, DISCOVERY_STATE_MIGRATING);
        // Reason code: 1 = timeout/disconnect detected during ACTIVE session
        discovery_session_handle_host_disconnect(session, 1);
      }
    }
    platform_sleep_us(timeout_ns / 1000);
    break;
 
  case DISCOVERY_STATE_MIGRATING:
    // Host migration in progress
    // Check if migration has timed out (if it takes >30 seconds, give up)
    if (session->migration.state == MIGRATION_STATE_COMPLETE) {
      // Migration completed successfully
      set_state(session, DISCOVERY_STATE_ACTIVE);
      log_info("Migration complete, session resumed");
    } else if (session_get_current_time_ms() - session->migration.detection_time_ms > 30 * MS_PER_SEC_INT) {
      // Migration timed out after 30 seconds
      log_error("Host migration timeout - session cannot recover");
      set_state(session, DISCOVERY_STATE_FAILED);
      session->error = ERROR_NETWORK;
    }
    platform_sleep_us(timeout_ns / 1000);
    break;
 
  default:
    SET_ERRNO(ERROR_INVALID_STATE, "Invalid session state");
    break;
  }
 
  return ASCIICHAT_OK;
}

◆ discovery_session_start()

asciichat_error_t discovery_session_start ( discovery_session_t * session )

Start the discovery session.

Connects to ACDS and either creates or joins a session.

Parameters

session Session context

Returns: ASCIICHAT_OK on success

Definition at line 1209 of file src/discovery/session.c.

                                                                        {
  log_info("discovery_session_start: ENTRY - session=%p", session);
 
  if (!session) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
  }
 
  log_info("discovery_session_start: is_initiator=%d, session_string='%s'", session->is_initiator,
           session->session_string);
 
  // Check if we should exit before starting blocking operations
  if (session->should_exit_callback && session->should_exit_callback(session->exit_callback_data)) {
    log_info("discovery_session_start: Exiting early due to should_exit_callback (before ACDS connect)");
    return ASCIICHAT_OK; // Return success to allow clean shutdown
  }
 
  log_info("discovery_session_start: Calling connect_to_acds...");
  // Connect to ACDS
  asciichat_error_t result = connect_to_acds(session);
  if (result != ASCIICHAT_OK) {
    log_error("discovery_session_start: connect_to_acds FAILED - result=%d", result);
    return result;
  }
  log_info("discovery_session_start: connect_to_acds succeeded");
 
  // Check again after connection
  if (session->should_exit_callback && session->should_exit_callback(session->exit_callback_data)) {
    log_info("discovery_session_start: Exiting early due to should_exit_callback (after ACDS connect)");
    return ASCIICHAT_OK; // Return success to allow clean shutdown
  }
 
  // Create or join session
  if (session->is_initiator) {
    log_info("discovery_session_start: Calling create_session - participant_ctx before=%p", session->participant_ctx);
    asciichat_error_t result = create_session(session);
    log_info("discovery_session_start: create_session returned - participant_ctx after=%p, result=%d",
             session->participant_ctx, result);
    return result;
  } else {
    log_info("discovery_session_start: Calling join_session - participant_ctx before=%p", session->participant_ctx);
    asciichat_error_t result = join_session(session);
    log_info("discovery_session_start: join_session returned - participant_ctx after=%p, state=%d, result=%d",
             session->participant_ctx, session->state, result);
    return result;
  }
}

References discovery_session_t::exit_callback_data, discovery_session_t::is_initiator, discovery_session_t::participant_ctx, discovery_session_t::session_string, discovery_session_t::should_exit_callback, and discovery_session_t::state.

Referenced by discovery_main().

◆ discovery_session_start_ring_round()

asciichat_error_t discovery_session_start_ring_round ( discovery_session_t * session )

Start a new ring consensus round (every 5 minutes or on new joiner)

Parameters

session Session context

Returns: ASCIICHAT_OK on success

Definition at line 1928 of file src/discovery/session.c.

                                                                                   {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  session->ring.last_ring_round_ms = session_get_current_time_ms();
 
  if (session->is_host) {
    log_info("Starting 5-minute proactive election round (collecting NETWORK_QUALITY from participants)");
 
    // HOST: Run proactive host election
    // 1. Collect NETWORK_QUALITY from all connected participants (TODO: request fresh data)
    // 2. Measure the host's own NAT quality
    // 3. Run deterministic election to determine future host
    // 4. Broadcast FUTURE_HOST_ELECTED to all participants via ACDS
    asciichat_error_t result = discovery_session_run_election(session);
    if (result != ASCIICHAT_OK) {
      log_error("Host election failed: %d", result);
      return result;
    }
 
    return ASCIICHAT_OK;
  } else {
    log_debug("Ring round timer triggered (waiting for host to broadcast FUTURE_HOST_ELECTED)");
    return ASCIICHAT_OK;
  }
}

References discovery_session_t::is_host, ring_consensus_t::last_ring_round_ms, and discovery_session_t::ring.

◆ discovery_session_stop()

void discovery_session_stop ( discovery_session_t * session )

Stop the discovery session.

Parameters

session Session context

Definition at line 1752 of file src/discovery/session.c.

                                                          {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return;
  }
 
  log_info("Stopping discovery session...");
 
  // Send SESSION_LEAVE if connected
  if (session->acds_socket != INVALID_SOCKET_VALUE && session->session_id[0] != 0) {
    acip_session_leave_t leave_msg;
    memset(&leave_msg, 0, sizeof(leave_msg));
    memcpy(leave_msg.session_id, session->session_id, 16);
    memcpy(leave_msg.participant_id, session->participant_id, 16);
 
    packet_send(session->acds_socket, PACKET_TYPE_ACIP_SESSION_LEAVE, &leave_msg, sizeof(leave_msg));
  }
 
  set_state(session, DISCOVERY_STATE_ENDED);
}

References discovery_session_t::acds_socket, DISCOVERY_STATE_ENDED, packet_send(), discovery_session_t::participant_id, and discovery_session_t::session_id.

Referenced by discovery_main().

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ MAX_PARTICIPANTS

Typedef Documentation

◆ discovery_should_exit_fn

Enumeration Type Documentation

◆ discovery_state_t

◆ migration_state_t

Function Documentation

◆ discovery_session_become_host()

◆ discovery_session_check_host_alive()

◆ discovery_session_connect_to_future_host()

◆ discovery_session_create()

◆ discovery_session_destroy()

◆ discovery_session_get_future_host()

◆ discovery_session_get_host()

◆ discovery_session_get_participant()

◆ discovery_session_get_state()

◆ discovery_session_get_string()

◆ discovery_session_handle_host_disconnect()

◆ discovery_session_init_ring()

◆ discovery_session_is_active()

◆ discovery_session_is_future_host()

◆ discovery_session_is_host()

◆ discovery_session_process()

◆ discovery_session_start()

◆ discovery_session_start_ring_round()

◆ discovery_session_stop()