src/discovery/session.h

Go to the documentation of this file.

 
 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define DISCOVERY_SESSION_ACDS_ADDRESS_BUFFER_SIZE 64
#define DISCOVERY_SESSION_ACDS_URL_BUFFER_SIZE 512
 
#include <ascii-chat/network/acip/acds_sizes.h>
#include <ascii-chat/crypto/sizes.h>
#include <ascii-chat/network/connection.h>
#include <ascii-chat/crypto/handshake/common.h>
 
#pragma once
#include <ascii-chat/crypto/handshake/common.h>
 
#include <ascii-chat/asciichat_errno.h>
#include "negotiate.h"
#include <libplatform/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 <libplatform/compiler.h>
#include <libplatform/system.h>
#include <libplatform/mutex.h>
#include <libplatform/terminal.h>
#include <stdbool.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
  uint64_t last_ping_sent_ms;     
  atomic_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 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[SESSION_ID_SIZE];
  uint8_t participant_id[SESSION_ID_SIZE];
  uint8_t initiator_id[SESSION_ID_SIZE];
  char session_string[SESSION_STRING_BUFFER_SIZE];
  char password[ACIP_PASSWORD_SIZE]; 
  bool is_initiator;
  bool is_host;
  bool host_elected; 
 
  // Identity keys (Ed25519) - Multi-key support
  uint8_t identity_pubkey[ED25519_PUBLIC_KEY_SIZE];  
  uint8_t identity_seckey[ED25519_PRIVATE_KEY_SIZE]; 
 
  // Multi-key support: all identity keys for multi-key handshake
  uint8_t identity_pubkeys[MAX_SESSION_KEYS][ED25519_PUBLIC_KEY_SIZE];  
  uint8_t identity_seckeys[MAX_SESSION_KEYS][ED25519_PRIVATE_KEY_SIZE]; 
  size_t num_identity_keys;                                             
 
  // ACDS connection
  network_connection_t *acds_connection;
  acip_transport_t *acds_transport; 
  uint64_t last_acds_keepalive_ns;  
  char acds_address[DISCOVERY_SESSION_ACDS_ADDRESS_BUFFER_SIZE];
  uint16_t acds_port;
  char acds_url[DISCOVERY_SESSION_ACDS_URL_BUFFER_SIZE]; 
 
  // Host info (when not us)
  uint8_t host_id[SESSION_ID_SIZE];
  char host_address[ACIP_ADDRESS_SIZE];
  uint16_t host_port;
  uint8_t session_type; 
 
  // WebRTC credentials (for WebRTC sessions)
  char turn_username[ACIP_TURN_AUTH_SIZE];
  char turn_password[ACIP_PASSWORD_SIZE];
 
  // Negotiation (initial host negotiation)
  negotiate_ctx_t negotiate;
 
  // Optional NAT hint for fresh measured handoff probes
  nat_quality_t cached_nat_quality;
  bool nat_quality_cached;
  uint64_t nat_quality_measured_ms;
 
  // NAT detection threading (non-blocking background detection)
  platform_thread_t nat_detection_thread;
  bool nat_detection_thread_started;
  bool nat_detection_completed; 
  bool nat_detection_attempted;
  uint64_t nat_detection_last_attempt_ms;
  mutex_t nat_quality_mutex;
 
  // Host liveness detection (participants only)
  host_liveness_t liveness;
 
  uint64_t handoff_last_sample_ms;
  uint32_t handoff_sequence;
  uint32_t handoff_generation;
  bool handoff_pending;
  bool host_authority_received;
  uint32_t host_authority_generation;
  uint32_t host_authority_sequence;
 
  uint64_t host_loss_detected_ms; 
 
  // 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;
  acip_transport_t *host_control_transport;      
  network_connection_t *host_control_connection; 
 
  // 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);

asciichat_error_t 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_check_host_alive(discovery_session_t *session);

void discovery_session_host_pong(discovery_session_t *session);

asciichat_error_t discovery_session_handle_host_disconnect(discovery_session_t *session, uint32_t disconnect_reason);
 
#ifdef __cplusplus
}
#endif

asciichat_error_t discovery_session_apply_handoff(discovery_session_t *session);