src/discovery/session.h

Go to the documentation of this file.

 
#pragma once
 
#include <ascii-chat/asciichat_errno.h>
#include "negotiate.h"
#include <ascii-chat/platform/socket.h>
#include <ascii-chat/network/acip/transport.h>
#include "session/host.h"
#include "session/participant.h"
#include <ascii-chat/discovery/strings.h>
#include <ascii-chat/network/webrtc/stun.h>
#include <ascii-chat/network/webrtc/turn.h>
#include <ascii-chat/options/options.h>
#include <ascii-chat/platform/abstraction.h>
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Forward declarations
#if !defined(MAX_PARTICIPANTS)
#define MAX_PARTICIPANTS 16
#endif
 
typedef struct {
  // Future host information (pre-elected by host every 5 minutes)
  uint8_t future_host_id[16];          
  char future_host_address[64];        
  uint16_t future_host_port;           
  uint8_t future_host_connection_type; 
  bool am_future_host;                 
  uint64_t future_host_elected_round;  
 
  // Timing for next proactive election
  uint64_t last_ring_round_ms; 
} ring_consensus_t;
 
typedef struct {
  uint64_t last_ping_sent_ms;     
  uint64_t last_pong_received_ms; 
  uint32_t consecutive_failures;  
  uint32_t max_failures;          
  uint64_t ping_interval_ms;      
  uint64_t timeout_ms;            
  bool ping_in_flight;            
} host_liveness_t;
 
typedef enum {
  MIGRATION_STATE_NONE,     
  MIGRATION_STATE_DETECTED, 
  MIGRATION_STATE_FAILOVER, 
  MIGRATION_STATE_COMPLETE  
} migration_state_t;
 
typedef struct {
  migration_state_t state;    
  uint64_t detection_time_ms; 
  uint8_t last_host_id[16];   
  uint32_t disconnect_reason; 
} migration_ctx_t;
 
typedef bool (*discovery_should_exit_fn)(void *user_data);
 
typedef enum {
  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;
 
typedef struct {
  // State
  discovery_state_t state;
  asciichat_error_t error;
  uint64_t waiting_peer_start_ns; 
 
  // Session info
  uint8_t session_id[16];
  uint8_t participant_id[16];
  uint8_t initiator_id[16];
  char session_string[SESSION_STRING_BUFFER_SIZE];
  char password[128]; 
  bool is_initiator;
  bool is_host;
  bool host_elected; 
 
  // Identity keys (Ed25519) - Multi-key support
  uint8_t identity_pubkey[32]; 
  uint8_t identity_seckey[64]; 
 
  // Multi-key support: all identity keys for multi-key handshake
  uint8_t identity_pubkeys[MAX_IDENTITY_KEYS][32]; 
  size_t num_identity_keys;                        
 
  // ACDS connection
  acip_transport_t *acds_transport; 
  uint64_t last_acds_keepalive_ns;  
  char acds_address[64];
  uint16_t acds_port;
  char acds_url[512]; 
 
  // Host info (when not us)
  uint8_t host_id[16];
  char host_address[64];
  uint16_t host_port;
  uint8_t session_type; 
 
  // WebRTC credentials (for WebRTC sessions)
  char turn_username[128];
  char turn_password[128];
 
  // Negotiation (initial host negotiation)
  negotiate_ctx_t negotiate;
 
  // Cached NAT quality (gathered once, reused for NETWORK_QUALITY packets)
  nat_quality_t cached_nat_quality;
  bool nat_quality_cached;
 
  // NAT detection threading (non-blocking background detection)
  asciichat_thread_t nat_detection_thread;
  bool nat_detection_in_progress;
  bool nat_detection_thread_started;
  mutex_t nat_quality_mutex;
 
  // Ring Consensus (NEW P2P design)
  ring_consensus_t ring;
 
  // Host liveness detection (participants only)
  host_liveness_t liveness;
 
  // Migration state (host failover)
  migration_ctx_t migration;
 
  // WebRTC support (NEW)
  struct webrtc_peer_manager *peer_manager; 
  bool webrtc_transport_ready;              
  bool webrtc_connection_initiated;         
  int webrtc_retry_attempt;                 
  uint64_t webrtc_last_attempt_time_ms;     
  uint64_t webrtc_disconnected_since_ms;      
 
  // WebRTC ICE servers (for STUN/TURN support)
  // These must be stored in the session to keep memory valid for peer manager lifetime
  // Forward declare - actual types defined in network/webrtc/stun.h and network/webrtc/turn.h
  stun_server_t *stun_servers; 
  size_t stun_count;           
  turn_server_t *turn_servers; 
  size_t turn_count;           
 
  // Role contexts (only one is active at a time)
  session_host_t *host_ctx;
  session_participant_t *participant_ctx;
 
  // Callbacks for state changes
  void (*on_state_change)(discovery_state_t new_state, void *user_data);
  void (*on_session_ready)(const char *session_string, void *user_data);
  void (*on_error)(asciichat_error_t error, const char *message, void *user_data);
  void *callback_user_data;
 
  // Exit callback for graceful shutdown during blocking operations
  discovery_should_exit_fn should_exit_callback;
  void *exit_callback_data;
} discovery_session_t;
 
typedef struct {
  // ACDS server
  const char *acds_address; 
  uint16_t acds_port;       
  const char *acds_url;     
 
  // Session to join (NULL = create new)
  const char *session_string; 
  const char *password;       
 
  // Local server config (if we become host)
  uint16_t local_port; 
 
  // Callbacks
  void (*on_state_change)(discovery_state_t new_state, void *user_data);
  void (*on_session_ready)(const char *session_string, void *user_data);
  void (*on_error)(asciichat_error_t error, const char *message, void *user_data);
  void *callback_user_data;
 
  // Exit callback for graceful shutdown during blocking operations
  discovery_should_exit_fn should_exit_callback;
  void *exit_callback_data;
} discovery_config_t;
 
discovery_session_t *discovery_session_create(const discovery_config_t *config);
 
void discovery_session_destroy(discovery_session_t *session);
 
asciichat_error_t discovery_session_start(discovery_session_t *session);
 
asciichat_error_t discovery_session_process(discovery_session_t *session, int64_t timeout_ns);
 
void discovery_session_stop(discovery_session_t *session);
 
discovery_state_t discovery_session_get_state(const discovery_session_t *session);
 
bool discovery_session_is_active(const discovery_session_t *session);
 
const char *discovery_session_get_string(const discovery_session_t *session);
 
bool discovery_session_is_host(const discovery_session_t *session);
 
session_host_t *discovery_session_get_host(discovery_session_t *session);
 
session_participant_t *discovery_session_get_participant(discovery_session_t *session);
 
asciichat_error_t discovery_session_init_ring(discovery_session_t *session);
 
asciichat_error_t discovery_session_start_ring_round(discovery_session_t *session);
 
asciichat_error_t discovery_session_check_host_alive(discovery_session_t *session);
 
asciichat_error_t discovery_session_handle_host_disconnect(discovery_session_t *session, uint32_t disconnect_reason);
 
asciichat_error_t discovery_session_become_host(discovery_session_t *session);
 
asciichat_error_t discovery_session_connect_to_future_host(discovery_session_t *session);
 
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);
 
bool discovery_session_is_future_host(const discovery_session_t *session);
 
#ifdef __cplusplus
}
#endif