peer_manager.c File Reference

Go to the source code of this file.

Data Structures
struct	peer_entry_t
	Per-peer connection state. More...
struct	webrtc_peer_manager
	WebRTC peer manager structure. More...

Typedefs
typedef struct webrtc_peer_manager	webrtc_peer_manager_t
	WebRTC peer manager structure.

Functions
asciichat_error_t	webrtc_peer_manager_create (const webrtc_peer_manager_config_t *config, const webrtc_signaling_callbacks_t *signaling_callbacks, webrtc_peer_manager_t **manager_out)
void	webrtc_peer_manager_destroy (webrtc_peer_manager_t *manager)
asciichat_error_t	webrtc_peer_manager_handle_sdp (webrtc_peer_manager_t *manager, const acip_webrtc_sdp_t *sdp)
asciichat_error_t	webrtc_peer_manager_handle_ice (webrtc_peer_manager_t *manager, const acip_webrtc_ice_t *ice)
asciichat_error_t	webrtc_peer_manager_connect (webrtc_peer_manager_t *manager, const uint8_t session_id[16], const uint8_t participant_id[16])
int	webrtc_peer_manager_check_gathering_timeouts (webrtc_peer_manager_t *manager, uint32_t timeout_ms)

Typedef Documentation

webrtc_peer_manager_t

typedef struct webrtc_peer_manager webrtc_peer_manager_t

WebRTC peer manager structure.

Function Documentation

webrtc_peer_manager_check_gathering_timeouts()

int webrtc_peer_manager_check_gathering_timeouts	(	webrtc_peer_manager_t *	manager,
		uint32_t	timeout_ms
	)

Definition at line 525 of file peer_manager.c.

                                                                                                      {
  if (!manager) {
    return 0;
  }
 
  int timeout_count = 0;
  peer_entry_t *peer = NULL, *tmp = NULL;
 
  mutex_lock(&manager->peers_mutex);
 
  // Iterate through all peers and check for gathering timeout
  HASH_ITER(hh, manager->peers, peer, tmp) {
    if (!peer || !peer->pc) {
      continue;
    }
 
    // Check if this peer's ICE gathering has timed out
    if (webrtc_is_gathering_timed_out(peer->pc, timeout_ms)) {
      webrtc_gathering_state_t state = webrtc_get_gathering_state(peer->pc);
 
      log_error("ICE gathering timeout for peer (participant_id=%02x%02x%02x%02x..., timeout=%ums, state=%d)",
                peer->participant_id[0], peer->participant_id[1], peer->participant_id[2], peer->participant_id[3],
                timeout_ms, state);
 
      // Call timeout callback if configured
      if (manager->config.on_gathering_timeout) {
        manager->config.on_gathering_timeout(peer->participant_id, timeout_ms, timeout_ms, manager->config.user_data);
      }
 
      // Remove and close the timed-out peer connection
      remove_peer_locked(manager, peer);
      timeout_count++;
 
      log_info("Closed and removed timed-out peer connection (count: %d)", timeout_count);
    }
  }
 
  mutex_unlock(&manager->peers_mutex);
 
  return timeout_count;
}

References webrtc_peer_manager::config, peer_entry_t::participant_id, peer_entry_t::pc, webrtc_peer_manager::peers, webrtc_peer_manager::peers_mutex, webrtc_get_gathering_state(), and webrtc_is_gathering_timed_out().

Referenced by discovery_session_process().

webrtc_peer_manager_connect()

asciichat_error_t webrtc_peer_manager_connect	(	webrtc_peer_manager_t *	manager,
		const uint8_t	session_id[16],
		const uint8_t	participant_id[16]
	)

Definition at line 490 of file peer_manager.c.

                                                                                {
  if (!manager || !session_id || !participant_id) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  if (manager->role != WEBRTC_ROLE_JOINER) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Only joiners can initiate connections");
  }
 
  log_debug("webrtc_peer_manager_connect: session_id=%02x%02x%02x%02x..., participant_id=%02x%02x%02x%02x...",
            session_id[0], session_id[1], session_id[2], session_id[3], participant_id[0], participant_id[1],
            participant_id[2], participant_id[3]);
 
  mutex_lock(&manager->peers_mutex);
 
  // Create peer connection
  peer_entry_t *peer;
  asciichat_error_t result = create_peer_connection_locked(manager, session_id, participant_id, &peer);
  if (result != ASCIICHAT_OK) {
    mutex_unlock(&manager->peers_mutex);
    return SET_ERRNO(result, "Failed to create peer connection");
  }
 
  mutex_unlock(&manager->peers_mutex);
 
  // Note: SDP offer is automatically created by libdatachannel when rtcCreateDataChannel() is called
  // The on_local_description callback will be triggered automatically with the offer
  // No need to manually call webrtc_create_offer() - doing so causes "Unexpected local description" error
 
  log_info("Initiated WebRTC connection to participant (offer auto-created by DataChannel)");
 
  return ASCIICHAT_OK;
}

References participant_id, webrtc_peer_manager::peers_mutex, webrtc_peer_manager::role, and session_id.

Referenced by discovery_session_process().

webrtc_peer_manager_create()

asciichat_error_t webrtc_peer_manager_create	(	const webrtc_peer_manager_config_t *	config,
		const webrtc_signaling_callbacks_t *	signaling_callbacks,
		webrtc_peer_manager_t **	manager_out
	)

Definition at line 323 of file peer_manager.c.

                                                                                  {
  if (!config || !signaling_callbacks || !manager_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  if (!signaling_callbacks->send_sdp || !signaling_callbacks->send_ice) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Signaling callbacks required");
  }
 
  // Allocate manager
  webrtc_peer_manager_t *manager = SAFE_MALLOC(sizeof(webrtc_peer_manager_t), webrtc_peer_manager_t *);
  if (!manager) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate peer manager");
  }
 
  memcpy(&manager->config, config, sizeof(*config));
  memcpy(&manager->signaling, signaling_callbacks, sizeof(*signaling_callbacks));
  manager->role = config->role;
  manager->peers = NULL;
 
  if (mutex_init(&manager->peers_mutex) != 0) {
    SAFE_FREE(manager);
    return SET_ERRNO(ERROR_INTERNAL, "Failed to initialize peers mutex");
  }
 
  log_info("Created WebRTC peer manager (role: %s)", manager->role == WEBRTC_ROLE_CREATOR ? "creator" : "joiner");
 
  *manager_out = manager;
  return ASCIICHAT_OK;
}

References webrtc_peer_manager::config, mutex_init(), webrtc_peer_manager::peers, webrtc_peer_manager::peers_mutex, webrtc_peer_manager::role, and webrtc_peer_manager::signaling.

Referenced by server_main().

webrtc_peer_manager_destroy()

void webrtc_peer_manager_destroy

(

webrtc_peer_manager_t *

manager

)

Definition at line 356 of file peer_manager.c.

                                                                 {
  if (!manager) {
    return;
  }
 
  mutex_lock(&manager->peers_mutex);
 
  // Close all peer connections
  peer_entry_t *peer = NULL, *tmp = NULL;
  HASH_ITER(hh, manager->peers, peer, tmp) {
    remove_peer_locked(manager, peer);
  }
 
  mutex_unlock(&manager->peers_mutex);
  mutex_destroy(&manager->peers_mutex);
 
  SAFE_FREE(manager);
 
  log_debug("Destroyed WebRTC peer manager");
}

References mutex_destroy(), webrtc_peer_manager::peers, and webrtc_peer_manager::peers_mutex.

Referenced by discovery_session_destroy(), discovery_session_process(), and server_main().

webrtc_peer_manager_handle_ice()

asciichat_error_t webrtc_peer_manager_handle_ice	(	webrtc_peer_manager_t *	manager,
		const acip_webrtc_ice_t *	ice
	)

Definition at line 441 of file peer_manager.c.

                                                                                                               {
  if (!manager || !ice) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Extract ICE candidate and mid (both are null-terminated in the packet)
  const char *candidate = (const char *)(ice + 1); // After header
  size_t candidate_str_len = strlen(candidate);
  const char *mid = candidate + candidate_str_len + 1; // After candidate + null terminator
 
  log_debug("Handling incoming ICE candidate from remote peer (mid=%s)", mid);
  log_debug("  [3] After ACDS recv - candidate: '%s' (len=%zu)", candidate, strlen(candidate));
  log_debug("  [3] After ACDS recv - mid: '%s' (len=%zu)", mid, strlen(mid));
  log_debug("  [3] After ACDS recv - header.candidate_len=%u", NET_TO_HOST_U16(ice->candidate_len));
 
  // Hex dump first 100 bytes of payload for debugging
  const uint8_t *payload = (const uint8_t *)(ice + 1);
  log_debug("  [3] Hex dump of payload (first 100 bytes):");
  for (int i = 0; i < 100 && i < (int)candidate_str_len + 20; i += 16) {
    char hex[64] = {0};
    char ascii[20] = {0};
    for (int j = 0; j < 16 && (i + j) < 100; j++) {
      snprintf(hex + j * 3, sizeof(hex) - j * 3, "%02x ", payload[i + j]);
      ascii[j] = (payload[i + j] >= 32 && payload[i + j] < 127) ? payload[i + j] : '.';
    }
    log_debug("    [%04x] %-48s %s", i, hex, ascii);
  }
 
  mutex_lock(&manager->peers_mutex);
 
  // Find peer connection
  peer_entry_t *peer = find_peer_locked(manager, ice->sender_id);
  if (!peer) {
    mutex_unlock(&manager->peers_mutex);
    log_warn("ICE candidate for unknown peer, ignoring");
    return ASCIICHAT_OK;
  }
 
  mutex_unlock(&manager->peers_mutex);
 
  // Add remote ICE candidate
  asciichat_error_t result = webrtc_add_remote_candidate(peer->pc, candidate, mid);
  if (result != ASCIICHAT_OK) {
    return SET_ERRNO(result, "Failed to add remote ICE candidate");
  }
 
  return ASCIICHAT_OK;
}

References peer_entry_t::pc, webrtc_peer_manager::peers_mutex, and webrtc_add_remote_candidate().

webrtc_peer_manager_handle_sdp()

asciichat_error_t webrtc_peer_manager_handle_sdp	(	webrtc_peer_manager_t *	manager,
		const acip_webrtc_sdp_t *	sdp
	)

Definition at line 377 of file peer_manager.c.

                                                                                                               {
  if (!manager || !sdp) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Extract SDP string and type
  const uint8_t *sdp_data = (const uint8_t *)(sdp + 1); // After header
  const char *sdp_type = (sdp->sdp_type == 0) ? "offer" : "answer";
  uint16_t sdp_len = NET_TO_HOST_U16(sdp->sdp_len);
 
  // Allocate null-terminated buffer for SDP string (libdatachannel requires C string)
  char *sdp_str = SAFE_MALLOC(sdp_len + 1, char *);
  memcpy(sdp_str, sdp_data, sdp_len);
  sdp_str[sdp_len] = '\0'; // Null-terminate
 
  log_debug("Handling incoming SDP %s from remote peer (len=%u)", sdp_type, sdp_len);
 
  mutex_lock(&manager->peers_mutex);
 
  // Find or create peer connection
  peer_entry_t *peer;
 
  // Special case: If receiving an answer and we're a joiner, we may have created
  // a peer with broadcast ID (00000000...) and need to update it to the real sender_id
  if (sdp->sdp_type == 1 && manager->role == WEBRTC_ROLE_JOINER) {
    static const uint8_t broadcast_id[16] = {0};
    peer = find_peer_locked(manager, broadcast_id);
    if (peer) {
      log_debug("Updating broadcast peer with real participant_id from answer");
      // Remove from hash with old ID
      HASH_DEL(manager->peers, peer);
      // Update to real participant_id
      memcpy(peer->participant_id, sdp->sender_id, 16);
      // Re-add with new ID
      HASH_ADD(hh, manager->peers, participant_id, 16, peer);
    }
  }
 
  asciichat_error_t result = create_peer_connection_locked(manager, sdp->session_id, sdp->sender_id, &peer);
  if (result != ASCIICHAT_OK) {
    mutex_unlock(&manager->peers_mutex);
    SAFE_FREE(sdp_str);
    return SET_ERRNO(result, "Failed to create peer connection for SDP");
  }
 
  mutex_unlock(&manager->peers_mutex);
 
  // Set remote SDP
  result = webrtc_set_remote_description(peer->pc, sdp_str, sdp_type);
  SAFE_FREE(sdp_str); // Free after use
 
  if (result != ASCIICHAT_OK) {
    return SET_ERRNO(result, "Failed to set remote SDP");
  }
 
  // If this is an offer and we're the creator, generate answer automatically
  // (libdatachannel triggers on_local_description callback with answer)
  if (sdp->sdp_type == 0 && manager->role == WEBRTC_ROLE_CREATOR) {
    log_debug("Offer received, answer will be generated automatically");
  }
 
  return ASCIICHAT_OK;
}

References peer_entry_t::participant_id, participant_id, peer_entry_t::pc, webrtc_peer_manager::peers, webrtc_peer_manager::peers_mutex, webrtc_peer_manager::role, and webrtc_set_remote_description().