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.

Macro Definition Documentation

◆ MAX_PARTICIPANTS

#define MAX_PARTICIPANTS 16

Definition at line 36 of file src/discovery/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 114 of file src/discovery/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 119 of file src/discovery/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 88 of file src/discovery/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 2455 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, session->host_address, sizeof(announcement.host_address));
  announcement.host_port = host_port;
  // Set connection type based on NAT quality (for now use DIRECT_PUBLIC for localhost dev environments)
  announcement.connection_type = ACIP_CONNECTION_TYPE_DIRECT_PUBLIC;
 
  if (session->acds_transport) {
    packet_send_via_transport(session->acds_transport, PACKET_TYPE_ACIP_HOST_ANNOUNCEMENT, &announcement,
                              sizeof(announcement), 0);
    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_transport, ACIP_CONNECTION_TYPE_DIRECT_PUBLIC, acip_host_announcement_t, ASCIICHAT_OK, DISCOVERY_STATE_ACTIVE, ERROR_INVALID_PARAM, ERROR_MEMORY, GET_OPTION, discovery_session_t::host_address, discovery_session_t::host_ctx, discovery_session_t::is_host, log_error, log_info, discovery_session_t::migration, MIGRATION_STATE_COMPLETE, packet_send_via_transport(), PACKET_TYPE_ACIP_HOST_ANNOUNCEMENT, discovery_session_t::participant_id, session_host_config_t::port, SAFE_STRNCPY, session_host_create(), session_host_start(), discovery_session_t::session_id, SET_ERRNO, 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 2332 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 ASCIICHAT_OK, host_liveness_t::consecutive_failures, ERROR_NETWORK, INVALID_SOCKET_VALUE, discovery_session_t::is_host, host_liveness_t::last_ping_sent_ms, discovery_session_t::liveness, log_debug, log_error, log_warn, host_liveness_t::max_failures, discovery_session_t::migration, MIGRATION_STATE_NONE, packet_send(), PACKET_TYPE_PING, 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, SESSION_TYPE_WEBRTC, 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 2520 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_config_t::address, ASCIICHAT_OK, DISCOVERY_STATE_ACTIVE, ERROR_INVALID_PARAM, ERROR_MEMORY, 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, log_error, log_info, discovery_session_t::migration, MIGRATION_STATE_COMPLETE, discovery_session_t::participant_ctx, discovery_session_t::ring, SAFE_STRNCPY, session_participant_connect(), session_participant_create(), session_participant_destroy(), SET_ERRNO, 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 51 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_transport = NULL;
  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->webrtc_disconnected_since_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);
  }
 
  // Load multiple identity keys from options (multi-key protocol support)
  const options_t *opts = options_get();
  if (opts && opts->num_identity_keys > 0) {
    // Load all identity keys from options
    for (size_t i = 0; i < opts->num_identity_keys && i < MAX_IDENTITY_KEYS; i++) {
      uint8_t pubkey[32] = {0};
      uint8_t seckey[64] = {0};
      asciichat_error_t key_result = acds_identity_load(opts->identity_keys[i], pubkey, seckey);
      if (key_result == ASCIICHAT_OK) {
        memcpy(session->identity_pubkeys[i], pubkey, 32);
        char fingerprint[65];
        acds_identity_fingerprint(pubkey, fingerprint);
        log_info("Loaded identity key #%zu with fingerprint: %.16s...", i + 1, fingerprint);
      } else {
        log_warn("Failed to load identity key #%zu from %s", i + 1, opts->identity_keys[i]);
      }
    }
    session->num_identity_keys = opts->num_identity_keys;
    log_info("Loaded %zu identity key(s) for multi-key protocol", session->num_identity_keys);
  } else {
    // Single-key mode: use only the primary identity key
    memcpy(session->identity_pubkeys[0], session->identity_pubkey, 32);
    session->num_identity_keys = 1;
  }
 
  // ACDS connection info
  if (config->acds_url && config->acds_url[0]) {
    SAFE_STRNCPY(session->acds_url, config->acds_url, sizeof(session->acds_url));
  }
  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;
  }
  if (config->password && config->password[0]) {
    SAFE_STRNCPY(session->password, config->password, sizeof(session->password));
  }
 
  // 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;
 
  // Initialize mutex for NAT quality protection
  if (mutex_init(&session->nat_quality_mutex, "discovery_nat_quality") != 0) {
    log_warn("Failed to initialize NAT quality mutex");
  }
 
  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 180 of file src/discovery/session.c.

                                                             {
  if (!session) {
    SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
    return;
  }
 
  // Close ACDS connection
  if (session->acds_transport) {
    acip_transport_destroy(session->acds_transport);
    session->acds_transport = NULL;
  }
 
  // 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;
  }
 
  // Wait for NAT detection thread to complete if still running (with 500ms timeout)
  if (session->nat_detection_thread_started) {
    log_debug("Waiting for NAT detection thread to complete (500ms timeout)...");
    int join_result = asciichat_thread_join_timeout(&session->nat_detection_thread, NULL, 500 * 1000 * 1000); // 500ms
    if (join_result != 0) {
      log_warn("NAT detection thread did not exit within 500ms, continuing cleanup anyway");
    }
    session->nat_detection_thread_started = false;
  }
 
  // Destroy NAT quality mutex
  mutex_destroy(&session->nat_quality_mutex);
 
  SAFE_FREE(session);
}

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 2576 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 ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NOT_FOUND, 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::ring, SAFE_STRNCPY, and SET_ERRNO.

◆ 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 2177 of file src/discovery/session.c.

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

References ERROR_INVALID_PARAM, discovery_session_t::host_ctx, and SET_ERRNO.

◆ 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 2185 of file src/discovery/session.c.

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

References ERROR_INVALID_PARAM, discovery_session_t::participant_ctx, and SET_ERRNO.

◆ 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 2145 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, ERROR_INVALID_PARAM, SET_ERRNO, 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 2161 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 ERROR_INVALID_PARAM, discovery_session_t::session_string, and SET_ERRNO.

◆ 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 2405 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_via_transport(session->acds_transport, PACKET_TYPE_ACIP_HOST_LOST, &host_lost, sizeof(host_lost), 0);
 
  // 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_transport, acip_host_lost_t, 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(), ERROR_INVALID_PARAM, ERROR_NETWORK, 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, log_error, log_info, log_warn, discovery_session_t::migration, MIGRATION_STATE_COMPLETE, MIGRATION_STATE_DETECTED, MIGRATION_STATE_FAILOVER, packet_send_via_transport(), PACKET_TYPE_ACIP_HOST_LOST, discovery_session_t::participant_id, discovery_session_t::ring, discovery_session_t::session_id, SET_ERRNO, 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 2287 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, ASCIICHAT_OK, ERROR_INVALID_PARAM, ring_consensus_t::future_host_id, ring_consensus_t::last_ring_round_ms, log_info, discovery_session_t::ring, and SET_ERRNO.

◆ 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 2153 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, ERROR_INVALID_PARAM, SET_ERRNO, 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 2597 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, ERROR_INVALID_PARAM, discovery_session_t::ring, and SET_ERRNO.

◆ 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 2169 of file src/discovery/session.c.

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

References ERROR_INVALID_PARAM, discovery_session_t::is_host, and SET_ERRNO.

◆ 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 1516 of file src/discovery/session.c.

                                                                                              {
  if (!session) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "session is NULL");
  }
 
  // Media traffic uses a separate transport; keep the signaling connection alive.
  if (session->acds_transport && acip_transport_is_connected(session->acds_transport)) {
    uint64_t now_ns = time_get_ns();
    if (now_ns - session->last_acds_keepalive_ns >= 5 * NS_PER_SEC_INT) {
      asciichat_error_t ping_result = acip_send_ping(session->acds_transport);
      if (ping_result != ASCIICHAT_OK)
        return ping_result;
      session->last_acds_keepalive_ns = now_ns;
    }
  }
  // Handle state-specific processing
  switch (session->state) {
  case DISCOVERY_STATE_WAITING_PEER: {
    // Wait for PARTICIPANT_JOINED notification from ACDS
    // Note: don't use a hard timeout here - let the outer process timeout (snapshot delay) control max wait
    // The discovery_run() loop will keep calling this until session becomes active or process exits
    uint64_t now_ns = time_get_ns();
    uint64_t wait_duration = now_ns - session->waiting_peer_start_ns;
 
    log_debug("★ WAITING_PEER: duration=%.3fs (no timeout, waiting for peer...)", wait_duration / 1e9);
 
    if (session->acds_transport && timeout_ns > 0) {
      // Do not set socket timeout - let receive_packet_secure use its own timeout
      // Setting a short socket timeout conflicts with its hardcoded 1-second timeout
      packet_type_t type;
      void *data = NULL;
      size_t len = 0;
      void *alloc_buffer = NULL;
 
      // Try to receive a packet
      asciichat_error_t recv_result =
          packet_receive_via_transport(session->acds_transport, &type, &data, &len, &alloc_buffer);
      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);
          buffer_pool_free(NULL, alloc_buffer, 0);
        } else {
          // Got some other packet, handle it or ignore
          log_debug("Received packet type %d while waiting for peer", type);
          buffer_pool_free(NULL, alloc_buffer, 0);
        }
      } 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 transport
      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 so peers can evaluate us
      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);
      }
 
      // ACDS relays NETWORK_QUALITY only to OTHER participants, not back to sender
      // For now in discovery mode, assume we're the only one and become host immediately
      // A real implementation would wait for peer to join via PARTICIPANT_JOINED, then connect directly
      log_info("Proceeding as host (ACDS cannot relay peer quality in solo mode)");
      session->negotiate.our_quality.detection_complete = true;
      session->negotiate.peer_quality_received = true;
      memset(&session->negotiate.peer_quality, 0, sizeof(session->negotiate.peer_quality));
      // Mark peer quality as detected but with worst NAT type so we win host election
      session->negotiate.peer_quality.detection_complete = true;
      session->negotiate.peer_quality.nat_type = ACIP_NAT_TYPE_SYMMETRIC;
    }
 
    // Check for HOST_ANNOUNCEMENT from ACDS (in case we're waiting for host discovery)
    if (session->acds_transport && !session->is_initiator && !session->host_address[0]) {
      packet_type_t type;
      void *data = NULL;
      size_t len = 0;
      void *alloc_buffer = NULL;
 
      asciichat_error_t recv_result =
          packet_receive_via_transport(session->acds_transport, &type, &data, &len, &alloc_buffer);
      if (recv_result == ASCIICHAT_OK && type == PACKET_TYPE_ACIP_HOST_ANNOUNCEMENT) {
        acip_host_announcement_t *announcement = (acip_host_announcement_t *)data;
        log_info("Received HOST_ANNOUNCEMENT from ACDS: %s:%u", announcement->host_address, announcement->host_port);
        SAFE_STRNCPY(session->host_address, announcement->host_address, sizeof(session->host_address));
        session->host_port = announcement->host_port;
        buffer_pool_free(NULL, alloc_buffer, 0);
        // Continue to host role determination below
      } else if (recv_result == ASCIICHAT_OK) {
        buffer_pool_free(NULL, alloc_buffer, 0);
      }
    }
 
    // Determine host role (now that peer_quality is set)
    if (session->negotiate.peer_quality_received && session->negotiate.state != NEGOTIATE_STATE_COMPARING) {
      log_info("Determining host role based on NAT qualities...");
      asciichat_error_t result = negotiate_determine_result(&session->negotiate);
      if (result == ASCIICHAT_OK) {
        session->is_host = session->negotiate.we_are_host;
 
        if (session->is_host) {
          // We 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;
 
          // Fallback to localhost if NAT detection failed to determine address
          if (!session->host_address[0]) {
            log_warn("NAT address empty, using localhost fallback");
            SAFE_STRNCPY(session->host_address, "127.0.0.1", sizeof(session->host_address));
          }
 
          set_state(session, DISCOVERY_STATE_STARTING_HOST);
        } else {
          // They are host (shouldn't happen in solo mode, but handle it)
          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;
 
          // If host address is empty, wait for HOST_ANNOUNCEMENT from ACDS instead of using fallback
          if (!session->host_address[0]) {
            log_info("Waiting for HOST_ANNOUNCEMENT from ACDS to discover host address...");
            // Stay in NEGOTIATING state to continue waiting for HOST_ANNOUNCEMENT
            break;
          }
 
          set_state(session, DISCOVERY_STATE_CONNECTING_HOST);
        }
      } else {
        log_error("Failed to determine negotiation result: %d", result);
        set_error(session, result, "Host election failed");
      }
    }
    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);
    }
 
    // Send HOST_ANNOUNCEMENT to ACDS so participants can discover us
    int host_port = GET_OPTION(port);
    acip_host_announcement_t announcement = {0};
    memcpy(announcement.session_id, session->session_id, 16);
    memcpy(announcement.host_id, session->host_id, 16);
    SAFE_STRNCPY(announcement.host_address, session->host_address, sizeof(announcement.host_address));
    announcement.host_port = host_port;
    announcement.connection_type = ACIP_CONNECTION_TYPE_DIRECT_PUBLIC;
 
    if (session->acds_transport) {
      packet_send_via_transport(session->acds_transport, PACKET_TYPE_ACIP_HOST_ANNOUNCEMENT, &announcement,
                                sizeof(announcement), 0);
      log_info("Sent HOST_ANNOUNCEMENT to ACDS at %s:%u", announcement.host_address, announcement.host_port);
    }
 
    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 = APP_CALLBACK_UINT64(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("WebRTC negotiation failed: %d peer(s) failed or exceeded the %dms gathering timeout",
                    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
            APP_CALLBACK_VOID(platform_pump_events);
            APP_CALLBACK_VOID_UINT(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) || GET_OPTION(webrtc_relay_only)) {
                log_fatal("WebRTC connection failed and direct fallback is disabled");
                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) || GET_OPTION(webrtc_relay_only)) {
              log_fatal("WebRTC connection failed and direct fallback is disabled");
              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_transport && acip_transport_has_pending_data(session->acds_transport)) {
        packet_type_t type;
        void *data = NULL;
        size_t len = 0;
        void *alloc_buffer = NULL;
 
        asciichat_error_t recv_result =
            packet_receive_via_transport(session->acds_transport, &type, &data, &len, &alloc_buffer);
 
        if (recv_result == ASCIICHAT_OK) {
          // Dispatch to appropriate handler
          handle_acds_webrtc_packet(session, type, data, len);
          buffer_pool_free(NULL, alloc_buffer, 0);
        } else if (!acip_transport_is_connected(session->acds_transport)) {
          set_error(session, recv_result, "Discovery signaling connection closed during WebRTC negotiation");
          set_state(session, DISCOVERY_STATE_FAILED);
          return recv_result;
        } 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_transport &&
        acip_transport_has_pending_data(session->acds_transport)) {
      packet_type_t type;
      void *data = NULL;
      size_t len = 0;
      void *alloc_buffer = NULL;
 
      asciichat_error_t recv_result =
          packet_receive_via_transport(session->acds_transport, &type, &data, &len, &alloc_buffer);
 
      if (recv_result == ASCIICHAT_OK) {
        // Dispatch to appropriate handler
        handle_acds_webrtc_packet(session, type, data, len);
        buffer_pool_free(NULL, alloc_buffer, 0);
      }
    }
 
    if (session->session_type == SESSION_TYPE_WEBRTC && !session->is_host && session->peer_manager) {
      webrtc_state_t peer_state = WEBRTC_STATE_CLOSED;
      bool peer_found = webrtc_peer_manager_get_state(session->peer_manager, session->host_id, &peer_state);
      uint64_t now_ms = session_get_current_time_ms();
      bool disconnected_too_long = false;
 
      if (peer_found && peer_state == WEBRTC_STATE_DISCONNECTED) {
        if (session->webrtc_disconnected_since_ms == 0) {
          session->webrtc_disconnected_since_ms = now_ms;
        } else {
          disconnected_too_long = now_ms - session->webrtc_disconnected_since_ms >= 5000;
        }
      } else {
        session->webrtc_disconnected_since_ms = 0;
      }
 
      bool peer_failed = !peer_found || peer_state == WEBRTC_STATE_FAILED || peer_state == WEBRTC_STATE_CLOSED;
      if (session->webrtc_transport_ready && (peer_failed || disconnected_too_long)) {
        int max_attempts = GET_OPTION(webrtc_reconnect_attempts);
        if (session->webrtc_retry_attempt >= max_attempts) {
          set_error(session, ERROR_NETWORK, "WebRTC peer remained disconnected after retry attempts");
          return ERROR_NETWORK;
        }
 
        log_warn("WebRTC peer lost connectivity; resetting its transport and renegotiating");
        if (session->participant_ctx) {
          acip_transport_t *transport = session_participant_get_transport(session->participant_ctx);
          session_participant_set_transport(session->participant_ctx, NULL);
          acip_transport_destroy(transport);
        }
 
        // The transport has now closed its borrowed peer objects. The manager
        // can release the failed peer before creating the next offer.
        webrtc_peer_manager_remove_peer(session->peer_manager, session->host_id);
        session->webrtc_transport_ready = false;
        session->webrtc_connection_initiated = false;
        session->webrtc_disconnected_since_ms = 0;
        session->webrtc_retry_attempt++;
        set_state(session, DISCOVERY_STATE_CONNECTING_HOST);
        break;
      }
    }
 
    // 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 || opts->webrtc_relay_only)) {
          log_fatal("WebRTC connection failed and direct fallback is disabled");
          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;
 
  case DISCOVERY_STATE_FAILED:
    // Session has failed - return error on further processing
    return session->error != ASCIICHAT_OK ? session->error : ERROR_NETWORK;
 
  case DISCOVERY_STATE_ENDED:
    // Session has ended gracefully - return OK
    return ASCIICHAT_OK;
 
  case DISCOVERY_STATE_INIT:
  case DISCOVERY_STATE_CONNECTING_ACDS:
  case DISCOVERY_STATE_CREATING_SESSION:
  case DISCOVERY_STATE_JOINING_SESSION:
    // These states are handled during discovery_session_start(), not in the process loop
    // If we reach here, something went wrong - sleep and wait
    log_debug("discovery_session_process: State %d should be handled by discovery_session_start", session->state);
    platform_sleep_us(timeout_ns / 1000);
    break;
 
  default:
    return SET_ERRNO(ERROR_INVALID_STATE, "Invalid session state: %d", session->state);
  }
 
  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 1327 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);
    set_state(session, DISCOVERY_STATE_FAILED);
    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
  }
 
  // Perform crypto handshake with ACDS (same as client-server handshake)
  log_info("discovery_session_start: Performing crypto handshake with ACDS...");
  crypto_handshake_context_t handshake_ctx;
  memset(&handshake_ctx, 0, sizeof(handshake_ctx));
 
  result = crypto_handshake_init("discovery_client", &handshake_ctx, false);
  if (result != ASCIICHAT_OK) {
    log_error("discovery_session_start: Handshake init failed - %s", asciichat_error_string(result));
    set_error(session, result, "Crypto handshake init failed");
    return result;
  }
 
  // Store identity key in handshake context
  handshake_ctx.client_public_key.type = KEY_TYPE_ED25519;
  handshake_ctx.client_private_key.type = KEY_TYPE_ED25519;
  memcpy(handshake_ctx.client_public_key.key, session->identity_pubkey, 32);
  memcpy(handshake_ctx.client_private_key.key.ed25519, session->identity_seckey, 64);
 
  // Step 0: Send protocol version to ACDS
  log_debug("Sending protocol version to ACDS...");
  protocol_version_packet_t client_version = {0};
  client_version.protocol_version = HOST_TO_NET_U16(1);
  client_version.protocol_revision = HOST_TO_NET_U16(0);
  client_version.supports_encryption = 1;
  client_version.compression_algorithms = 0;
  client_version.compression_threshold = 0;
  client_version.feature_flags = 0;
 
  result = packet_send_via_transport(session->acds_transport, PACKET_TYPE_PROTOCOL_VERSION, &client_version,
                                     sizeof(client_version), 0);
  if (result != ASCIICHAT_OK) {
    log_error("discovery_session_start: Failed to send protocol version to ACDS");
    set_error(session, result, "Failed to send protocol version to ACDS");
    return result;
  }
 
  // Step 0.5: Receive CRYPTO_PARAMETERS from ACDS
  {
    packet_type_t pkt_type;
    void *pkt_data = NULL;
    size_t pkt_len = 0;
    void *alloc_buffer = NULL;
 
    result = packet_receive_via_transport(session->acds_transport, &pkt_type, &pkt_data, &pkt_len, &alloc_buffer);
    if (result != ASCIICHAT_OK || pkt_type != PACKET_TYPE_CRYPTO_PARAMETERS) {
      log_error("discovery_session_start: Failed to receive CRYPTO_PARAMETERS (got type %u)", pkt_type);
      buffer_pool_free(NULL, alloc_buffer, 0);
      set_error(session, result != ASCIICHAT_OK ? result : ERROR_NETWORK_PROTOCOL,
                "Failed to receive CRYPTO_PARAMETERS");
      return result != ASCIICHAT_OK ? result : ERROR_NETWORK_PROTOCOL;
    }
 
    if (pkt_len != sizeof(crypto_parameters_packet_t)) {
      log_error("discovery_session_start: Invalid CRYPTO_PARAMETERS size: %zu (expected %zu)", pkt_len,
                sizeof(crypto_parameters_packet_t));
      buffer_pool_free(NULL, alloc_buffer, 0);
      set_error(session, ERROR_NETWORK_PROTOCOL, "Invalid CRYPTO_PARAMETERS size");
      return ERROR_NETWORK_PROTOCOL;
    }
 
    crypto_parameters_packet_t server_params;
    memcpy(&server_params, pkt_data, sizeof(crypto_parameters_packet_t));
    buffer_pool_free(NULL, alloc_buffer, 0);
 
    // Pass params in network byte order — crypto_handshake_set_parameters
    // handles conversion internally for client (is_server=false)
    result = crypto_handshake_set_parameters(&handshake_ctx, &server_params);
    if (result != ASCIICHAT_OK) {
      log_error("discovery_session_start: Failed to set crypto parameters");
      set_error(session, result, "Failed to set crypto parameters");
      return result;
    }
    log_info("discovery_session_start: CRYPTO_PARAMETERS received and applied");
  }
 
  // Step 1: Key exchange - receive KEY_EXCHANGE_INIT and respond
  {
    packet_type_t pkt_type;
    void *pkt_data = NULL;
    size_t pkt_len = 0;
    void *alloc_buffer = NULL;
 
    result = packet_receive_via_transport(session->acds_transport, &pkt_type, &pkt_data, &pkt_len, &alloc_buffer);
    if (result != ASCIICHAT_OK) {
      log_error("discovery_session_start: Failed to receive KEY_EXCHANGE_INIT");
      set_error(session, result, "Handshake key exchange recv failed");
      return result;
    }
 
    result = crypto_handshake_client_key_exchange(&handshake_ctx, session->acds_transport, pkt_type, pkt_data, pkt_len);
    buffer_pool_free(NULL, alloc_buffer, 0);
 
    if (result != ASCIICHAT_OK) {
      log_error("discovery_session_start: Handshake key exchange failed");
      set_error(session, result, "Handshake key exchange failed");
      return result;
    }
  }
 
  // Step 2: Receive CRYPTO_HANDSHAKE_COMPLETE from server to finalize handshake
  {
    packet_type_t pkt_type;
    void *pkt_data = NULL;
    size_t pkt_len = 0;
    void *alloc_buffer = NULL;
 
    result = packet_receive_via_transport(session->acds_transport, &pkt_type, &pkt_data, &pkt_len, &alloc_buffer);
    if (result != ASCIICHAT_OK) {
      log_error("discovery_session_start: Failed to receive CRYPTO_HANDSHAKE_COMPLETE");
      set_error(session, result, "Failed to receive handshake complete");
      return result;
    }
 
    if (pkt_type != PACKET_TYPE_CRYPTO_HANDSHAKE_COMPLETE) {
      log_error("discovery_session_start: Expected CRYPTO_HANDSHAKE_COMPLETE, got packet type %d", pkt_type);
      buffer_pool_free(NULL, alloc_buffer, 0);
      set_error(session, ERROR_NETWORK_PROTOCOL, "Invalid crypto handshake completion packet");
      return ERROR_NETWORK_PROTOCOL;
    }
 
    buffer_pool_free(NULL, alloc_buffer, 0);
  }
 
  // For ACDS, handshake completes after key exchange (no auth required)
  log_info("discovery_session_start: ACDS handshake complete");
  log_info("discovery_session_start: Crypto handshake with ACDS completed");
 
  // Check again after handshake
  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 handshake)");
    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);
    result = create_session(session);
    log_info("discovery_session_start: create_session returned - participant_ctx after=%p, result=%d",
             session->participant_ctx, result);
 
    if (result == ASCIICHAT_OK) {
      // Initiator also needs to register itself as a participant so it can receive PARTICIPANT_JOINED notifications
      // when other peers join. This makes the initiator discoverable to other participants.
      log_info("Initiator: now registering self as participant in created session");
      result = join_session(session);
      log_info("Initiator: join_session result=%d", 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;
  }
}

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 2303 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 ASCIICHAT_OK, ERROR_INVALID_PARAM, discovery_session_t::is_host, ring_consensus_t::last_ring_round_ms, log_debug, log_error, log_info, discovery_session_t::ring, and SET_ERRNO.

◆ discovery_session_stop()

void discovery_session_stop ( discovery_session_t * session )

Stop the discovery session.

Parameters

session Session context

Definition at line 2123 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_transport && 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_via_transport(session->acds_transport, PACKET_TYPE_ACIP_SESSION_LEAVE, &leave_msg, sizeof(leave_msg),
                              0);
  }
 
  set_state(session, DISCOVERY_STATE_ENDED);
}

References discovery_session_t::acds_transport, acip_session_leave_t, DISCOVERY_STATE_ENDED, ERROR_INVALID_PARAM, log_info, packet_send_via_transport(), PACKET_TYPE_ACIP_SESSION_LEAVE, discovery_session_t::participant_id, discovery_session_t::session_id, and SET_ERRNO.

Referenced by discovery_main().

Data Structures

Macros

Typedefs

Enumerations

Functions

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