WebRTC Peer Manager

Manage WebRTC peer connections for session participants. More...

Data Structures
struct	webrtc_peer_manager_config_t
	Peer manager configuration. More...
struct	webrtc_signaling_callbacks_t
	Signaling callbacks for sending SDP/ICE. More...

Typedefs
typedef struct webrtc_peer_manager	webrtc_peer_manager_t
typedef void(*	webrtc_transport_ready_callback_t) (acip_transport_t *transport, const uint8_t participant_id[16], void *user_data)
	Callback when DataChannel is ready and wrapped in ACIP transport.
typedef void(*	webrtc_gathering_timeout_callback_t) (const uint8_t participant_id[16], uint32_t timeout_ms, uint64_t elapsed_ms, void *user_data)
	Callback when ICE candidate gathering is unusually slow.
typedef asciichat_error_t(*	webrtc_send_sdp_callback_t) (const uint8_t session_id[16], const uint8_t recipient_id[16], const char *sdp_type, const char *sdp, void *user_data)
	Callback to send SDP via ACDS signaling.
typedef asciichat_error_t(*	webrtc_send_ice_callback_t) (const uint8_t session_id[16], const uint8_t recipient_id[16], const char *candidate, const char *mid, void *user_data)
	Callback to send ICE candidate via ACDS signaling.

Enumerations
enum	webrtc_peer_role_t { WEBRTC_ROLE_CREATOR = 0 , WEBRTC_ROLE_JOINER = 1 }
	Peer connection role (server or client) More...

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)
	Create a WebRTC peer manager.
void	webrtc_peer_manager_destroy (webrtc_peer_manager_t *manager)
	Destroy peer manager and close all connections.
asciichat_error_t	webrtc_peer_manager_handle_sdp (webrtc_peer_manager_t *manager, const acip_webrtc_sdp_t *sdp)
	Handle incoming SDP message from ACDS.
asciichat_error_t	webrtc_peer_manager_handle_ice (webrtc_peer_manager_t *manager, const acip_webrtc_ice_t *ice)
	Handle incoming ICE candidate from ACDS.
asciichat_error_t	webrtc_peer_manager_connect (webrtc_peer_manager_t *manager, const uint8_t session_id[16], const uint8_t participant_id[16])
	Initiate connection to remote peer (joiner role only)
bool	webrtc_peer_manager_get_state (webrtc_peer_manager_t *manager, const uint8_t participant_id[16], webrtc_state_t *state_out)
asciichat_error_t	webrtc_peer_manager_remove_peer (webrtc_peer_manager_t *manager, const uint8_t participant_id[16])
int	webrtc_peer_manager_check_gathering_timeouts (webrtc_peer_manager_t *manager, uint32_t timeout_ms)
	Report slow ICE gathering and remove failed connections.

Detailed Description

Manage WebRTC peer connections for session participants.

Typedef Documentation

webrtc_gathering_timeout_callback_t

typedef void(* webrtc_gathering_timeout_callback_t) (const uint8_t participant_id[16], uint32_t timeout_ms, uint64_t elapsed_ms, void *user_data)

#include <peer_manager.h>

Callback when ICE candidate gathering is unusually slow.

Parameters

participant_id	Remote participant UUID (16 bytes)
timeout_ms	Configured timeout in milliseconds
elapsed_ms	Actual elapsed time in milliseconds
user_data	User context pointer

Called once when a peer connection's ICE gathering exceeds the configured timeout. Trickle ICE may still connect the peer, so this callback does not imply that the peer connection will be closed.

Definition at line 84 of file peer_manager.h.

webrtc_peer_manager_t

typedef struct webrtc_peer_manager webrtc_peer_manager_t

#include <peer_manager.h>

Definition at line 50 of file peer_manager.h.

webrtc_send_ice_callback_t

typedef asciichat_error_t(* webrtc_send_ice_callback_t) (const uint8_t session_id[16], const uint8_t recipient_id[16], const char *candidate, const char *mid, void *user_data)

#include <peer_manager.h>

Callback to send ICE candidate via ACDS signaling.

Parameters

session_id	Session UUID (16 bytes)
recipient_id	Recipient participant UUID (16 bytes, all zeros for broadcast)
candidate	ICE candidate string (null-terminated)
mid	Media stream ID (null-terminated)
user_data	User context pointer

Returns

ASCIICHAT_OK on success, error code on failure

Implementation should send PACKET_TYPE_ACIP_WEBRTC_ICE via ACDS.

Definition at line 131 of file peer_manager.h.

webrtc_send_sdp_callback_t

typedef asciichat_error_t(* webrtc_send_sdp_callback_t) (const uint8_t session_id[16], const uint8_t recipient_id[16], const char *sdp_type, const char *sdp, void *user_data)

#include <peer_manager.h>

Callback to send SDP via ACDS signaling.

Parameters

session_id	Session UUID (16 bytes)
recipient_id	Recipient participant UUID (16 bytes, all zeros for broadcast)
sdp_type	SDP type ("offer" or "answer")
sdp	SDP string (null-terminated)
user_data	User context pointer

Returns

ASCIICHAT_OK on success, error code on failure

Implementation should send PACKET_TYPE_ACIP_WEBRTC_SDP via ACDS.

Definition at line 117 of file peer_manager.h.

webrtc_transport_ready_callback_t

typedef void(* webrtc_transport_ready_callback_t) (acip_transport_t *transport, const uint8_t participant_id[16], void *user_data)

#include <peer_manager.h>

Callback when DataChannel is ready and wrapped in ACIP transport.

Parameters

transport	ACIP transport wrapping the WebRTC DataChannel
participant_id	Remote participant UUID (16 bytes)
user_data	User context pointer

The callback receives ownership of the transport and must either:

• Use it for ACIP communication
• Call acip_transport_destroy() to free it

Definition at line 70 of file peer_manager.h.

Enumeration Type Documentation

webrtc_peer_role_t

enum webrtc_peer_role_t

#include <peer_manager.h>

Peer connection role (server or client)

Enumerator
WEBRTC_ROLE_CREATOR	Session creator - accepts offers, generates answers.
WEBRTC_ROLE_JOINER	Session joiner - generates offers, receives answers.

Definition at line 55 of file peer_manager.h.

             {
  WEBRTC_ROLE_CREATOR = 0, 
  WEBRTC_ROLE_JOINER = 1,  
} webrtc_peer_role_t;

Function Documentation

webrtc_peer_manager_check_gathering_timeouts()

int webrtc_peer_manager_check_gathering_timeouts	(	webrtc_peer_manager_t *	manager,
		uint32_t	timeout_ms
	)

#include <peer_manager.h>

Report slow ICE gathering and remove failed connections.

Parameters

manager	Peer manager
timeout_ms	Timeout threshold in milliseconds

Returns

Number of failed or closed peer connections removed

Iterates through all active peer connections and checks if ICE gathering has exceeded the specified timeout or the connection has failed or closed. Slow gathering is reported once but left active because trickle ICE may still establish the connection. Failed or closed connections are removed.

This should be called periodically (e.g., every 100ms) during connection establishment to detect and handle gathering failures.

Note

Thread-safe - uses internal locking

Definition at line 754 of file peer_manager.c.

                                                                                                      {
  if (!manager) {
    return 0;
  }
 
  int timeout_count = 0;
  peer_entry_t *peer = NULL, *tmp = NULL;
 
  mutex_lock(&manager->signaling_mutex);
  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;
    }
 
    // Trickle ICE can connect before gathering completes. Report a slow gather,
    // but keep the peer alive until libdatachannel reports a failed connection.
    webrtc_state_t connection_state = webrtc_get_state(peer->pc);
    bool gathering_timed_out = webrtc_is_gathering_timed_out(peer->pc, timeout_ms);
    if (gathering_timed_out && !peer->gathering_timeout_reported) {
      peer->gathering_timeout_reported = true;
      if (manager->config.on_gathering_timeout) {
        manager->config.on_gathering_timeout(peer->participant_id, timeout_ms, timeout_ms, manager->config.user_data);
      }
      log_warn("ICE gathering exceeded %ums; keeping peer alive while trickle ICE continues", timeout_ms);
    }
 
    if (connection_state == WEBRTC_STATE_FAILED || connection_state == WEBRTC_STATE_CLOSED) {
      webrtc_gathering_state_t state = webrtc_get_gathering_state(peer->pc);
 
      log_error("WebRTC negotiation failed for peer (participant_id=%02x%02x%02x%02x..., timeout=%ums, "
                "gathering=%d, connection=%d)",
                peer->participant_id[0], peer->participant_id[1], peer->participant_id[2], peer->participant_id[3],
                timeout_ms, state, connection_state);
 
      // Remove and close peers whose ICE connection has actually failed.
      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);
  mutex_unlock(&manager->signaling_mutex);
 
  return timeout_count;
}

References config, peer_entry_t::gathering_timeout_reported, log_error, log_info, log_warn, mutex_lock, mutex_unlock, webrtc_peer_manager_config_t::on_gathering_timeout, peer_entry_t::participant_id, peer_entry_t::pc, peers, peers_mutex, signaling_mutex, webrtc_peer_manager_config_t::user_data, webrtc_get_gathering_state(), webrtc_get_state(), webrtc_is_gathering_timed_out(), WEBRTC_STATE_CLOSED, and WEBRTC_STATE_FAILED.

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

#include <peer_manager.h>

Initiate connection to remote peer (joiner role only)

Parameters

manager	Peer manager
session_id	Session UUID (16 bytes)
participant_id	Remote participant UUID to connect to (16 bytes)

Returns

ASCIICHAT_OK on success, error code on failure

Creates peer connection, generates SDP offer, and sends via signaling. Only valid for WEBRTC_ROLE_JOINER (session joiners initiate connections).

Creator role uses webrtc_peer_manager_handle_sdp() to accept offers instead.

Definition at line 684 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 ASCIICHAT_OK, ERROR_INVALID_PARAM, log_debug, log_info, mutex_lock, mutex_unlock, participant_id, peers_mutex, role, session_id, SET_ERRNO, and WEBRTC_ROLE_JOINER.

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
	)

#include <peer_manager.h>

Create a WebRTC peer manager.

Parameters

config	Manager configuration
signaling_callbacks	Callbacks for sending SDP/ICE
manager_out	Output parameter for manager handle

Returns

ASCIICHAT_OK on success, error code on failure

Creates a manager for WebRTC peer connections. The manager handles:

• Peer connection creation and lifecycle
• SDP offer/answer generation and processing
• ICE candidate exchange
• ACIP transport wrapping when DataChannel opens

Definition at line 431 of file peer_manager.c.

                                                                                  {
  if (!config || !signaling_callbacks || !manager_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
  *manager_out = NULL;
 
  if (!signaling_callbacks->send_sdp || !signaling_callbacks->send_ice) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Signaling callbacks required");
  }
  if (config->relay_only && config->turn_count == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Relay only requires a TURN server with credentials");
  }
 
  // 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;
  manager->pending_ice = NULL;
  manager->pending_ice_count = 0;
 
  if (mutex_init(&manager->peers_mutex, "peers") != 0) {
    SAFE_FREE(manager);
    return SET_ERRNO(ERROR_INTERNAL, "Failed to initialize peers mutex");
  }
  if (mutex_init(&manager->signaling_mutex, "webrtc_signaling") != 0) {
    mutex_destroy(&manager->peers_mutex);
    SAFE_FREE(manager);
    return SET_ERRNO(ERROR_INTERNAL, "Failed to initialize WebRTC signaling mutex");
  }
 
  log_info("Created WebRTC peer manager (role: %s)", manager->role == WEBRTC_ROLE_CREATOR ? "creator" : "joiner");
 
  *manager_out = manager;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, config, ERROR_INTERNAL, ERROR_INVALID_PARAM, ERROR_MEMORY, log_info, mutex_destroy(), mutex_init(), peers, peers_mutex, pending_ice, pending_ice_count, webrtc_peer_manager_config_t::relay_only, webrtc_peer_manager_config_t::role, role, SAFE_FREE, SAFE_MALLOC, webrtc_signaling_callbacks_t::send_ice, webrtc_signaling_callbacks_t::send_sdp, SET_ERRNO, signaling, signaling_mutex, webrtc_peer_manager_config_t::turn_count, and WEBRTC_ROLE_CREATOR.

webrtc_peer_manager_destroy()

void webrtc_peer_manager_destroy

(

webrtc_peer_manager_t *

manager

)

#include <peer_manager.h>

Destroy peer manager and close all connections.

Parameters

manager

Peer manager to destroy

Closes all active peer connections gracefully and frees resources. Safe to call with NULL pointer.

Definition at line 475 of file peer_manager.c.

                                                                 {
  if (!manager) {
    return;
  }
 
  mutex_lock(&manager->signaling_mutex);
  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);
  pending_ice_candidate_t *pending = manager->pending_ice;
  while (pending) {
    pending_ice_candidate_t *next = pending->next;
    free_pending_ice_candidate(pending);
    pending = next;
  }
  mutex_unlock(&manager->signaling_mutex);
  mutex_destroy(&manager->signaling_mutex);
  mutex_destroy(&manager->peers_mutex);
 
  SAFE_FREE(manager);
 
  log_debug("Destroyed WebRTC peer manager");
}

References log_debug, mutex_destroy(), mutex_lock, mutex_unlock, pending_ice_candidate::next, peers, peers_mutex, pending_ice, SAFE_FREE, and signaling_mutex.

Referenced by discovery_session_destroy(), and discovery_session_process().

webrtc_peer_manager_get_state()

bool webrtc_peer_manager_get_state	(	webrtc_peer_manager_t *	manager,
		const uint8_t	participant_id[16],
		webrtc_state_t *	state_out
	)

#include <peer_manager.h>

Return the current state for a participant's peer connection.

Definition at line 719 of file peer_manager.c.

                                                              {
  if (!manager || !participant_id || !state_out) {
    return false;
  }
 
  mutex_lock(&manager->peers_mutex);
  peer_entry_t *peer = find_peer_locked(manager, participant_id);
  bool found = peer && peer->pc;
  if (found) {
    *state_out = webrtc_get_state(peer->pc);
  }
  mutex_unlock(&manager->peers_mutex);
  return found;
}

References mutex_lock, mutex_unlock, participant_id, peer_entry_t::pc, peers_mutex, and webrtc_get_state().

Referenced by discovery_session_process().

webrtc_peer_manager_handle_ice()

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

#include <peer_manager.h>

Handle incoming ICE candidate from ACDS.

Parameters

manager	Peer manager
ice	ICE candidate message received from ACDS

Returns

ASCIICHAT_OK on success, error code on failure

Adds remote ICE candidate to the appropriate peer connection. If peer connection doesn't exist yet, queues candidate for later.

Definition at line 626 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);
  }
 
  // Do not pass a candidate to libdatachannel until a preceding SDP packet has
  // finished installing the remote ICE transport.
  mutex_lock(&manager->signaling_mutex);
  mutex_lock(&manager->peers_mutex);
 
  // Find peer connection
  peer_entry_t *peer = find_peer_locked(manager, ice->sender_id);
  if (!peer || !peer->remote_description_set) {
    mutex_unlock(&manager->peers_mutex);
    asciichat_error_t result = queue_pending_ice_candidate(manager, ice->sender_id, candidate, mid);
    mutex_unlock(&manager->signaling_mutex);
    if (result == ASCIICHAT_OK) {
      log_debug("Queued ICE candidate received before remote SDP was installed");
    }
    return result;
  }
 
  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) {
    mutex_unlock(&manager->signaling_mutex);
    return SET_ERRNO(result, "Failed to add remote ICE candidate");
  }
 
  mutex_unlock(&manager->signaling_mutex);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_debug, mutex_lock, mutex_unlock, NET_TO_HOST_U16, peer_entry_t::pc, peers_mutex, peer_entry_t::remote_description_set, SET_ERRNO, signaling_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
	)

#include <peer_manager.h>

Handle incoming SDP message from ACDS.

Parameters

manager	Peer manager
sdp	SDP message received from ACDS

Returns

ASCIICHAT_OK on success, error code on failure

Processes SDP offer or answer from remote peer:

• Creator role + offer: Create peer connection, set remote SDP, generate answer
• Joiner role + answer: Set remote SDP on existing peer connection

Sends response SDP via signaling callbacks.

Definition at line 505 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);
 
  // ACDS can deliver ICE immediately after SDP. Keep both operations ordered
  // until libdatachannel has installed the remote description and ICE transport.
  mutex_lock(&manager->signaling_mutex);
 
  // Allocate null-terminated buffer for SDP string (libdatachannel requires C string)
  char *sdp_str = SAFE_MALLOC(sdp_len + 1, char *);
  if (!sdp_str) {
    mutex_unlock(&manager->signaling_mutex);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate remote SDP buffer");
  }
  memcpy(sdp_str, sdp_data, sdp_len);
  sdp_str[sdp_len] = '\0'; // Null-terminate
 
  char incoming_ice_ufrag[257] = {0};
  bool has_incoming_ice_ufrag = extract_ice_ufrag(sdp_str, incoming_ice_ufrag, sizeof(incoming_ice_ufrag));
 
  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);
    }
  }
 
  // libdatachannel cannot apply an ICE restart to an existing peer connection.
  // Repeated signaling can also redeliver the same offer, which must not be
  // mistaken for a new ICE generation or applied twice.
  if (sdp->sdp_type == 0 && manager->role == WEBRTC_ROLE_CREATOR) {
    peer_entry_t *existing = find_peer_locked(manager, sdp->sender_id);
    if (existing && existing->remote_sdp_attempted && existing->pc) {
      webrtc_state_t state = webrtc_get_state(existing->pc);
      bool comparable_ice_generation = has_incoming_ice_ufrag && existing->remote_ice_ufrag[0] != '\0';
      bool new_ice_generation = comparable_ice_generation &&
                                strcmp(incoming_ice_ufrag, existing->remote_ice_ufrag) != 0;
      bool terminal_state = state == WEBRTC_STATE_FAILED || state == WEBRTC_STATE_CLOSED;
      if (!terminal_state && comparable_ice_generation && !new_ice_generation && existing->remote_description_set) {
        log_debug("Ignoring duplicate WebRTC offer for existing ICE generation");
        mutex_unlock(&manager->peers_mutex);
        SAFE_FREE(sdp_str);
        mutex_unlock(&manager->signaling_mutex);
        return ASCIICHAT_OK;
      }
      if (terminal_state || new_ice_generation) {
        log_info("Replacing WebRTC peer for %s", new_ice_generation ? "new ICE generation" : "terminal connection state");
        remove_peer_locked(manager, existing);
      }
    }
  }
 
  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);
    mutex_unlock(&manager->signaling_mutex);
    return SET_ERRNO(result, "Failed to create peer connection for SDP");
  }
 
  if (sdp->sdp_type == 0 && manager->role == WEBRTC_ROLE_CREATOR) {
    peer->remote_sdp_attempted = true;
  }
 
  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) {
    mutex_unlock(&manager->signaling_mutex);
    return SET_ERRNO(result, "Failed to set remote SDP");
  }
 
  // A peer entry can be created before its offer arrives (for example when
  // ACDS reports a participant join). Do not treat that entry as ready for
  // trickle ICE until libdatachannel has accepted its remote description.
  peer->remote_description_set = true;
  if (sdp->sdp_type == 0 && has_incoming_ice_ufrag) {
    memcpy(peer->remote_ice_ufrag, incoming_ice_ufrag, strlen(incoming_ice_ufrag) + 1);
  }
 
  result = apply_pending_ice_candidates(manager, peer);
  if (result != ASCIICHAT_OK) {
    mutex_unlock(&manager->signaling_mutex);
    return SET_ERRNO(result, "Failed to apply ICE candidates queued before 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");
  }
 
  mutex_unlock(&manager->signaling_mutex);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_MEMORY, log_debug, log_info, mutex_lock, mutex_unlock, NET_TO_HOST_U16, peer_entry_t::participant_id, participant_id, peer_entry_t::pc, peers, peers_mutex, peer_entry_t::remote_description_set, peer_entry_t::remote_ice_ufrag, peer_entry_t::remote_sdp_attempted, role, SAFE_FREE, SAFE_MALLOC, SET_ERRNO, signaling_mutex, webrtc_get_state(), WEBRTC_ROLE_CREATOR, WEBRTC_ROLE_JOINER, webrtc_set_remote_description(), WEBRTC_STATE_CLOSED, and WEBRTC_STATE_FAILED.

webrtc_peer_manager_remove_peer()

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

#include <peer_manager.h>

Definition at line 735 of file peer_manager.c.

                                                                                     {
  if (!manager || !participant_id) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Peer manager and participant ID are required");
  }
 
  // SDP and ICE handlers retain peer pointers after releasing peers_mutex.
  // Serialize removal with those handlers before freeing the peer wrappers.
  mutex_lock(&manager->signaling_mutex);
  mutex_lock(&manager->peers_mutex);
  peer_entry_t *peer = find_peer_locked(manager, participant_id);
  if (peer) {
    remove_peer_locked(manager, peer);
  }
  mutex_unlock(&manager->peers_mutex);
  mutex_unlock(&manager->signaling_mutex);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, mutex_lock, mutex_unlock, participant_id, peers_mutex, SET_ERRNO, and signaling_mutex.

Referenced by discovery_session_process().