webrtc.c File Reference

Go to the source code of this file.

Data Structures
struct	webrtc_peer_connection
	WebRTC peer connection state. More...
struct	webrtc_data_channel
	WebRTC data channel for sending/receiving messages. More...

Functions
asciichat_error_t	webrtc_init (void)
void	webrtc_destroy (void)
asciichat_error_t	webrtc_create_peer_connection (const webrtc_config_t *config, webrtc_peer_connection_t **pc_out)
void	webrtc_close_peer_connection (webrtc_peer_connection_t *pc)
webrtc_state_t	webrtc_get_state (webrtc_peer_connection_t *pc)
webrtc_gathering_state_t	webrtc_get_gathering_state (webrtc_peer_connection_t *pc)
bool	webrtc_is_gathering_timed_out (webrtc_peer_connection_t *pc, uint32_t timeout_ms)
void *	webrtc_get_user_data (webrtc_peer_connection_t *pc)
asciichat_error_t	webrtc_create_offer (webrtc_peer_connection_t *pc)
asciichat_error_t	webrtc_set_remote_description (webrtc_peer_connection_t *pc, const char *sdp, const char *type)
asciichat_error_t	webrtc_add_remote_candidate (webrtc_peer_connection_t *pc, const char *candidate, const char *mid)
asciichat_error_t	webrtc_create_datachannel (webrtc_peer_connection_t *pc, const char *label, webrtc_data_channel_t **dc_out)
asciichat_error_t	webrtc_datachannel_send (webrtc_data_channel_t *dc, const uint8_t *data, size_t size)
bool	webrtc_datachannel_is_open (webrtc_data_channel_t *dc)
void	webrtc_datachannel_set_open_state (webrtc_data_channel_t *dc, bool is_open)
const char *	webrtc_datachannel_get_label (webrtc_data_channel_t *dc)
void	webrtc_close_datachannel (webrtc_data_channel_t *dc)
asciichat_error_t	webrtc_datachannel_set_callbacks (webrtc_data_channel_t *dc, const webrtc_datachannel_callbacks_t *callbacks)
void	webrtc_datachannel_destroy (webrtc_data_channel_t *dc)
void	webrtc_peer_connection_close (webrtc_peer_connection_t *pc)
void	webrtc_peer_connection_destroy (webrtc_peer_connection_t *pc)
int	webrtc_get_rtc_id (webrtc_peer_connection_t *pc)
	Get the internal libdatachannel peer connection ID.

Function Documentation

webrtc_add_remote_candidate()

asciichat_error_t webrtc_add_remote_candidate	(	webrtc_peer_connection_t *	pc,
		const char *	candidate,
		const char *	mid
	)

Definition at line 587 of file lib/network/webrtc/webrtc.c.

                                                                                                                    {
  if (!pc || !candidate) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  log_debug("  [4] Before libdatachannel - candidate: '%s' (len=%zu)", candidate, strlen(candidate));
  log_debug("  [4] Before libdatachannel - mid: '%s' (len=%zu)", mid ? mid : "(null)", mid ? strlen(mid) : 0);
 
  int result = rtcAddRemoteCandidate(pc->rtc_id, candidate, mid);
  if (result != RTC_ERR_SUCCESS) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to add remote ICE candidate (rtc error %d)", result);
  }
 
  log_debug("Added remote ICE candidate (pc_id=%d)", pc->rtc_id);
  return ASCIICHAT_OK;
}

Referenced by ice_add_remote_candidate(), and webrtc_peer_manager_handle_ice().

webrtc_close_datachannel()

void webrtc_close_datachannel

(

webrtc_data_channel_t *

dc

)

Definition at line 709 of file lib/network/webrtc/webrtc.c.

                                                         {
  if (!dc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "DataChannel is NULL");
    return;
  }
 
  // Save the ID before freeing (dc might be partially freed already)
  int dc_id = dc->rtc_id;
 
  rtcDeleteDataChannel(dc_id);
  log_debug("Closed DataChannel (dc_id=%d)", dc_id);
 
  SAFE_FREE(dc);
}

Referenced by webrtc_close_peer_connection(), and webrtc_datachannel_destroy().

webrtc_close_peer_connection()

void webrtc_close_peer_connection

(

webrtc_peer_connection_t *

pc

)

Definition at line 480 of file lib/network/webrtc/webrtc.c.

                                                                {
  if (!pc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer connection");
    return;
  }
 
  // Close data channel if exists
  if (pc->dc) {
    webrtc_close_datachannel(pc->dc);
    pc->dc = NULL;
  }
 
  // Close peer connection
  rtcDeletePeerConnection(pc->rtc_id);
  log_debug("Closed WebRTC peer connection (id=%d)", pc->rtc_id);
 
  SAFE_FREE(pc);
}

References webrtc_close_datachannel().

webrtc_create_datachannel()

asciichat_error_t webrtc_create_datachannel	(	webrtc_peer_connection_t *	pc,
		const char *	label,
		webrtc_data_channel_t **	dc_out
	)

Definition at line 608 of file lib/network/webrtc/webrtc.c.

                                                                            {
  if (!pc || !label || !dc_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  // Create data channel
  int dc_id = rtcCreateDataChannel(pc->rtc_id, label);
  if (dc_id < 0) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to create data channel (rtc error %d)", dc_id);
  }
 
  // Allocate wrapper
  webrtc_data_channel_t *dc = SAFE_MALLOC(sizeof(webrtc_data_channel_t), webrtc_data_channel_t *);
  if (!dc) {
    rtcDeleteDataChannel(dc_id);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate data channel wrapper");
  }
 
  dc->rtc_id = dc_id;
  dc->pc = pc;
  dc->is_open = false;
 
  // Set up callbacks
  rtcSetUserPointer(dc_id, dc);
  rtcSetOpenCallback(dc_id, on_datachannel_open_adapter);
  rtcSetMessageCallback(dc_id, on_datachannel_message_adapter);
  rtcSetErrorCallback(dc_id, on_datachannel_error_adapter);
 
  pc->dc = dc;
  *dc_out = dc;
 
  log_debug("Created DataChannel '%s' (dc_id=%d, pc_id=%d)", label, dc_id, pc->rtc_id);
  return ASCIICHAT_OK;
}

webrtc_create_offer()

asciichat_error_t webrtc_create_offer

(

webrtc_peer_connection_t *

pc

)

Definition at line 554 of file lib/network/webrtc/webrtc.c.

                                                                    {
  if (!pc) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer connection");
  }
 
  // Set local description with NULL type to trigger offer generation
  int result = rtcSetLocalDescription(pc->rtc_id, NULL);
  if (result != RTC_ERR_SUCCESS) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to create SDP offer (rtc error %d)", result);
  }
 
  log_debug("Creating SDP offer (pc_id=%d)", pc->rtc_id);
  return ASCIICHAT_OK;
}

webrtc_create_peer_connection()

asciichat_error_t webrtc_create_peer_connection	(	const webrtc_config_t *	config,
		webrtc_peer_connection_t **	pc_out
	)

Definition at line 395 of file lib/network/webrtc/webrtc.c.

                                                                                                                  {
  if (!config || !pc_out) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid config or output parameter");
  }
 
  static_mutex_lock(&g_webrtc_refcount_mutex);
  bool is_initialized = (g_webrtc_init_refcount > 0);
  static_mutex_unlock(&g_webrtc_refcount_mutex);
 
  if (!is_initialized) {
    return SET_ERRNO(ERROR_INIT, "WebRTC library not initialized");
  }
 
  // Allocate peer connection wrapper
  webrtc_peer_connection_t *pc = SAFE_MALLOC(sizeof(webrtc_peer_connection_t), webrtc_peer_connection_t *);
  if (!pc) {
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate peer connection");
  }
 
  pc->config = *config; // Copy config
  pc->state = WEBRTC_STATE_NEW;
  pc->dc = NULL;
 
  // Build ICE server list for libdatachannel
  const char **ice_servers = NULL;
  size_t ice_count = 0;
 
  if (config->stun_count > 0 || config->turn_count > 0) {
    ice_count = config->stun_count + config->turn_count;
    ice_servers = SAFE_MALLOC(ice_count * sizeof(char *), const char **);
    if (!ice_servers) {
      SAFE_FREE(pc);
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate ICE server list");
    }
 
    // Add STUN servers
    for (size_t i = 0; i < config->stun_count; i++) {
      ice_servers[i] = config->stun_servers[i].host;
    }
 
    // Add TURN servers
    for (size_t i = 0; i < config->turn_count; i++) {
      ice_servers[config->stun_count + i] = config->turn_servers[i].url;
    }
  }
 
  // Create libdatachannel configuration
  rtcConfiguration rtc_config;
  memset(&rtc_config, 0, sizeof(rtc_config));
  rtc_config.iceServers = ice_servers;
  rtc_config.iceServersCount = (int)ice_count;
  rtc_config.iceTransportPolicy = RTC_TRANSPORT_POLICY_ALL;
 
  // Create peer connection
  int pc_id = rtcCreatePeerConnection(&rtc_config);
 
  // Free ICE server list (libdatachannel makes a copy)
  if (ice_servers) {
    SAFE_FREE(ice_servers);
  }
 
  if (pc_id < 0) {
    SAFE_FREE(pc);
    return SET_ERRNO(ERROR_NETWORK, "Failed to create peer connection (rtc error %d)", pc_id);
  }
 
  pc->rtc_id = pc_id;
 
  // Initialize gathering state
  pc->gathering_state = WEBRTC_GATHERING_NEW;
  pc->gathering_start_time_ms = 0;
 
  // Set up callbacks
  rtcSetUserPointer(pc_id, pc);
  rtcSetStateChangeCallback(pc_id, on_state_change_adapter);
  rtcSetGatheringStateChangeCallback(pc_id, on_gathering_state_change_adapter);
  rtcSetLocalDescriptionCallback(pc_id, on_local_description_adapter);
  rtcSetLocalCandidateCallback(pc_id, on_local_candidate_adapter);
  rtcSetDataChannelCallback(pc_id, on_datachannel_adapter);
 
  *pc_out = pc;
  log_debug("Created WebRTC peer connection (id=%d)", pc_id);
  return ASCIICHAT_OK;
}

webrtc_datachannel_destroy()

void webrtc_datachannel_destroy

(

webrtc_data_channel_t *

dc

)

Definition at line 770 of file lib/network/webrtc/webrtc.c.

                                                           {
  if (!dc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid null data channel");
    return;
  }
 
  // Close if still open, then free
  webrtc_close_datachannel(dc);
  // Note: webrtc_close_datachannel already calls SAFE_FREE(dc), so we're done
}

References webrtc_close_datachannel().

webrtc_datachannel_get_label()

const char * webrtc_datachannel_get_label

(

webrtc_data_channel_t *

dc

)

Definition at line 694 of file lib/network/webrtc/webrtc.c.

                                                                    {
  if (!dc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "DataChannel is NULL");
    return NULL;
  }
 
  static char label[256];
  int result = rtcGetDataChannelLabel(dc->rtc_id, label, sizeof(label));
  if (result < 0) {
    return NULL;
  }
 
  return label;
}

webrtc_datachannel_is_open()

bool webrtc_datachannel_is_open

(

webrtc_data_channel_t *

dc

)

Definition at line 678 of file lib/network/webrtc/webrtc.c.

                                                           {
  if (!dc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "DataChannel is NULL");
    return false;
  }
  return dc->is_open;
}

webrtc_datachannel_send()

asciichat_error_t webrtc_datachannel_send	(	webrtc_data_channel_t *	dc,
		const uint8_t *	data,
		size_t	size
	)

Definition at line 644 of file lib/network/webrtc/webrtc.c.

                                                                                                       {
  if (!dc || !data) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  if (!dc->is_open) {
    log_error("★ WEBRTC_DATACHANNEL_SEND: Channel not open! size=%zu, dc->rtc_id=%d", size, dc ? dc->rtc_id : -1);
    return SET_ERRNO(ERROR_NETWORK, "DataChannel not open");
  }
 
  // Log packet details at network layer (debug level for normal operation)
  if (size >= 20) {
    const uint8_t *pkt = (const uint8_t *)data;
    log_debug("★ RTCSENDMESSAGE_BEFORE: dc_id=%d, size=%zu, first_20_bytes: %02x%02x%02x%02x %02x%02x%02x%02x "
              "%02x%02x%02x%02x %02x%02x%02x%02x %02x%02x%02x%02x",
              dc->rtc_id, size, pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], pkt[9], pkt[10],
              pkt[11], pkt[12], pkt[13], pkt[14], pkt[15], pkt[16], pkt[17], pkt[18], pkt[19]);
  } else {
    log_debug("★ RTCSENDMESSAGE_BEFORE: dc_id=%d, size=%zu (too small to log content)", dc->rtc_id, size);
  }
 
  int result = rtcSendMessage(dc->rtc_id, (const char *)data, (int)size);
 
  log_debug("★ RTCSENDMESSAGE_AFTER: dc_id=%d, rtcSendMessage returned %d for size=%zu", dc->rtc_id, result, size);
 
  if (result < 0) {
    log_error("★ WEBRTC_DATACHANNEL_SEND: FAILED with error code %d", result);
    return SET_ERRNO(ERROR_NETWORK, "Failed to send data (rtc error %d)", result);
  }
 
  log_debug("★ WEBRTC_DATACHANNEL_SEND: SUCCESS - sent %zu bytes", size);
  return ASCIICHAT_OK;
}

webrtc_datachannel_set_callbacks()

asciichat_error_t webrtc_datachannel_set_callbacks	(	webrtc_data_channel_t *	dc,
		const webrtc_datachannel_callbacks_t *	callbacks
	)

Definition at line 728 of file lib/network/webrtc/webrtc.c.

                                                                                                    {
  if (!dc) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "DataChannel is NULL");
  }
 
  if (!callbacks) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Callbacks struct is NULL");
  }
 
  // Store user callbacks in the data channel struct
  dc->user_on_open = callbacks->on_open;
  dc->user_on_close = callbacks->on_close;
  dc->user_on_error = callbacks->on_error;
  dc->user_on_message = callbacks->on_message;
  dc->user_data = callbacks->user_data;
 
  // Register adapter functions with libdatachannel (adapters use correct signature)
  // The adapters will look up our stored callbacks and invoke them with proper types
  if (callbacks->on_open) {
    rtcSetOpenCallback(dc->rtc_id, on_datachannel_open_adapter);
  }
 
  if (callbacks->on_close) {
    rtcSetClosedCallback(dc->rtc_id, on_datachannel_closed_adapter);
  }
 
  if (callbacks->on_error) {
    rtcSetErrorCallback(dc->rtc_id, on_datachannel_error_adapter);
  }
 
  if (callbacks->on_message) {
    rtcSetMessageCallback(dc->rtc_id, on_datachannel_message_adapter);
  }
 
  // Set user pointer to the data channel so adapters can retrieve it
  rtcSetUserPointer(dc->rtc_id, dc);
 
  log_debug("Set DataChannel callbacks (dc_id=%d)", dc->rtc_id);
  return ASCIICHAT_OK;
}

Referenced by acip_webrtc_transport_create().

webrtc_datachannel_set_open_state()

void webrtc_datachannel_set_open_state	(	webrtc_data_channel_t *	dc,
		bool	is_open
	)

Definition at line 686 of file lib/network/webrtc/webrtc.c.

                                                                                {
  if (!dc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "DataChannel is NULL");
    return;
  }
  dc->is_open = is_open;
}

Referenced by acip_webrtc_transport_create().

webrtc_destroy()

void webrtc_destroy

(

void

)

Definition at line 387 of file lib/network/webrtc/webrtc.c.

                          {
  webrtc_release();
}

webrtc_get_gathering_state()

webrtc_gathering_state_t webrtc_get_gathering_state

(

webrtc_peer_connection_t *

pc

)

Definition at line 507 of file lib/network/webrtc/webrtc.c.

                                                                                  {
  if (!pc) {
    log_warn("Peer connection is NULL");
    return WEBRTC_GATHERING_NEW;
  }
  return pc->gathering_state;
}

Referenced by webrtc_peer_manager_check_gathering_timeouts().

webrtc_get_rtc_id()

int webrtc_get_rtc_id

(

webrtc_peer_connection_t *

pc

)

Get the internal libdatachannel peer connection ID.

Helper function for C++ code that needs access to internal rtc_id without exposing the full structure definition.

Parameters

pc	Peer connection

Returns

libdatachannel peer connection ID, or -1 if pc is NULL

Definition at line 817 of file lib/network/webrtc/webrtc.c.

                                                    {
  if (!pc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid null peer connectiont");
    return -1;
  }
  return pc->rtc_id;
}

Referenced by ice_get_selected_pair_impl().

webrtc_get_state()

webrtc_state_t webrtc_get_state

(

webrtc_peer_connection_t *

pc

)

Definition at line 499 of file lib/network/webrtc/webrtc.c.

                                                              {
  if (!pc) {
    log_warn("Peer connection is NULL");
    return WEBRTC_STATE_CLOSED;
  }
  return pc->state;
}

Referenced by ice_is_connected().

webrtc_get_user_data()

void * webrtc_get_user_data

(

webrtc_peer_connection_t *

pc

)

Definition at line 542 of file lib/network/webrtc/webrtc.c.

                                                         {
  if (!pc) {
    log_warn("Peer connection is NULL");
    return NULL;
  }
  return pc->config.user_data;
}

webrtc_init()

asciichat_error_t webrtc_init

(

void

)

Definition at line 383 of file lib/network/webrtc/webrtc.c.

                                    {
  return webrtc_ensure_initialized();
}

Referenced by server_main().

webrtc_is_gathering_timed_out()

bool webrtc_is_gathering_timed_out	(	webrtc_peer_connection_t *	pc,
		uint32_t	timeout_ms
	)

Definition at line 515 of file lib/network/webrtc/webrtc.c.

                                                                                      {
  if (!pc) {
    return false;
  }
 
  // Only check timeout if we're actively gathering
  if (pc->gathering_state != WEBRTC_GATHERING_GATHERING) {
    return false;
  }
 
  // If gathering hasn't started yet (start_time == 0), no timeout
  if (pc->gathering_start_time_ms == 0) {
    return false;
  }
 
  // Check if elapsed time exceeds timeout
  uint64_t current_time_ms = platform_get_monotonic_time_us() / 1000;
  uint64_t elapsed_ms = current_time_ms - pc->gathering_start_time_ms;
 
  if (elapsed_ms > timeout_ms) {
    log_warn("ICE gathering timeout: %llu ms elapsed (timeout: %u ms)", (unsigned long long)elapsed_ms, timeout_ms);
    return true;
  }
 
  return false;
}

References platform_get_monotonic_time_us().

Referenced by webrtc_peer_manager_check_gathering_timeouts().

webrtc_peer_connection_close()

void webrtc_peer_connection_close

(

webrtc_peer_connection_t *

pc

)

Definition at line 785 of file lib/network/webrtc/webrtc.c.

                                                                {
  if (!pc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid null peer connectiont");
    return;
  }
 
  rtcClose(pc->rtc_id);
  log_debug("Closed peer connection (pc_id=%d)", pc->rtc_id);
}

webrtc_peer_connection_destroy()

void webrtc_peer_connection_destroy

(

webrtc_peer_connection_t *

pc

)

Definition at line 795 of file lib/network/webrtc/webrtc.c.

                                                                  {
  if (!pc) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Invalid null peer connectiont");
    return;
  }
 
  // Close and delete peer connection
  rtcDeletePeerConnection(pc->rtc_id);
  log_debug("Destroyed peer connection (pc_id=%d)", pc->rtc_id);
 
  SAFE_FREE(pc);
}

webrtc_set_remote_description()

asciichat_error_t webrtc_set_remote_description	(	webrtc_peer_connection_t *	pc,
		const char *	sdp,
		const char *	type
	)

Definition at line 569 of file lib/network/webrtc/webrtc.c.

                                                                                                                 {
  if (!pc || !sdp || !type) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid parameters");
  }
 
  int result = rtcSetRemoteDescription(pc->rtc_id, sdp, type);
  if (result != RTC_ERR_SUCCESS) {
    return SET_ERRNO(ERROR_NETWORK, "Failed to set remote SDP (rtc error %d)", result);
  }
 
  log_debug("Set remote SDP description (pc_id=%d, type=%s)", pc->rtc_id, type);
  return ASCIICHAT_OK;
}

Referenced by webrtc_peer_manager_handle_sdp().