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

Detailed Description

Manage WebRTC peer connections for session participants.

Typedef Documentation

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 112 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 98 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_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 417 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");
  }
 
  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);
 
  // Create SDP offer (triggers on_local_description callback)
  result = webrtc_create_offer(peer->pc);
  if (result != ASCIICHAT_OK) {
    return SET_ERRNO(result, "Failed to create SDP offer");
  }
 
  log_info("Initiated WebRTC connection to participant");
 
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, log_info, mutex_lock, mutex_unlock, participant_id, peer_entry_t::pc, peers_mutex, role, session_id, SET_ERRNO, webrtc_create_offer(), and WEBRTC_ROLE_JOINER.

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 293 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 ASCIICHAT_OK, config, ERROR_INTERNAL, ERROR_INVALID_PARAM, ERROR_MEMORY, log_info, mutex_init(), peers, peers_mutex, role, webrtc_peer_manager_config_t::role, SAFE_FREE, SAFE_MALLOC, webrtc_signaling_callbacks_t::send_ice, webrtc_signaling_callbacks_t::send_sdp, SET_ERRNO, signaling, and WEBRTC_ROLE_CREATOR.

Referenced by server_main().

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 326 of file peer_manager.c.

                                                                 {
  if (!manager) {
    return;
  }
 
  mutex_lock(&manager->peers_mutex);
 
  // Close all peer connections
  peer_entry_t *peer, *tmp;
  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 log_debug, mutex_destroy(), mutex_lock, mutex_unlock, peers, peers_mutex, and SAFE_FREE.

Referenced by connection_context_cleanup(), 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
	)

#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 385 of file peer_manager.c.

                                                                                                               {
  if (!manager || !ice) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Extract ICE candidate and mid
  const char *candidate = (const char *)(ice + 1); // After header
  const char *mid = candidate + ice->candidate_len;
 
  log_debug("Handling incoming ICE candidate from remote peer");
 
  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 ASCIICHAT_OK, ERROR_INVALID_PARAM, log_debug, log_warn, mutex_lock, mutex_unlock, peer_entry_t::pc, peers_mutex, SET_ERRNO, 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 347 of file peer_manager.c.

                                                                                                               {
  if (!manager || !sdp) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Extract SDP string and type
  const char *sdp_str = (const char *)(sdp + 1); // After header
  const char *sdp_type = (sdp->sdp_type == 0) ? "offer" : "answer";
 
  log_debug("Handling incoming SDP %s from remote peer", sdp_type);
 
  mutex_lock(&manager->peers_mutex);
 
  // Find or create peer connection
  peer_entry_t *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);
    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);
  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 ASCIICHAT_OK, ERROR_INVALID_PARAM, log_debug, mutex_lock, mutex_unlock, peer_entry_t::pc, peers_mutex, role, SET_ERRNO, WEBRTC_ROLE_CREATOR, and webrtc_set_remote_description().