ice.c File Reference

ICE candidate gathering and exchange. More...

Go to the source code of this file.

Macros
#define	PCRE2_CODE_UNIT_WIDTH   8

Functions
const char *	ice_candidate_type_name (ice_candidate_type_t type)
const char *	ice_protocol_name (ice_protocol_t protocol)
uint32_t	ice_calculate_priority (ice_candidate_type_t type, uint16_t local_preference, uint8_t component_id)
uint32_t	ice_calculate_priority_for_candidate (const ice_candidate_t *candidate)
asciichat_error_t	ice_parse_candidate (const char *line, ice_candidate_t *candidate)
asciichat_error_t	ice_format_candidate (const ice_candidate_t *candidate, char *line, size_t line_size)
asciichat_error_t	ice_gather_candidates (const ice_config_t *config)
asciichat_error_t	ice_add_remote_candidate (webrtc_peer_connection_t *pc, const ice_candidate_t *candidate, const char *mid)
bool	ice_is_connected (webrtc_peer_connection_t *pc)
asciichat_error_t	ice_get_selected_pair_impl (webrtc_peer_connection_t *pc, ice_candidate_t *local_candidate, ice_candidate_t *remote_candidate)
	Get selected ICE candidate pair (C++ implementation)
asciichat_error_t	ice_get_selected_pair (webrtc_peer_connection_t *pc, ice_candidate_t *local_candidate, ice_candidate_t *remote_candidate)

Detailed Description

ICE candidate gathering and exchange.

Implements ICE candidate collection from STUN/TURN servers and relay via ACDS signaling.

Date

January 2026

Definition in file ice.c.

Macro Definition Documentation

PCRE2_CODE_UNIT_WIDTH

#define PCRE2_CODE_UNIT_WIDTH   8

Definition at line 20 of file ice.c.

Function Documentation

ice_add_remote_candidate()

asciichat_error_t ice_add_remote_candidate	(	webrtc_peer_connection_t *	pc,
		const ice_candidate_t *	candidate,
		const char *	mid
	)

Definition at line 423 of file ice.c.

                                                            {
  if (!pc || !candidate || !mid) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid remote candidate parameters");
  }
 
  // Validate candidate has required fields
  if (candidate->ip_address[0] == '\0' || candidate->port == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Candidate missing IP address or port");
  }
 
  log_debug("ICE: Adding remote candidate %s:%u (type=%s, foundation=%s) on mid=%s", candidate->ip_address,
            candidate->port, ice_candidate_type_name(candidate->type), candidate->foundation, mid);
 
  // Format candidate to SDP attribute line for libdatachannel
  char candidate_line[512];
  asciichat_error_t err = ice_format_candidate(candidate, candidate_line, sizeof(candidate_line));
  if (err != ASCIICHAT_OK) {
    return err;
  }
 
  // Delegate to WebRTC layer
  return webrtc_add_remote_candidate(pc, candidate_line, mid);
}

References ice_candidate_type_name(), ice_format_candidate(), and webrtc_add_remote_candidate().

ice_calculate_priority()

uint32_t ice_calculate_priority	(	ice_candidate_type_t	type,
		uint16_t	local_preference,
		uint8_t	component_id
	)

Definition at line 102 of file ice.c.

                                                                                                            {
  // RFC 5245: priority = (2^24 * typePreference) + (2^8 * localPreference) + (256 - componentID)
 
  // Type preference (higher is better):
  // - Host: 126 (most preferred, lowest latency)
  // - SRFLX: 100 (STUN-discovered address)
  // - PRFLX: 110 (discovered during connectivity checks)
  // - Relay: 0 (least preferred, uses bandwidth)
 
  uint8_t type_preference = 0;
  switch (type) {
  case ICE_CANDIDATE_HOST:
    type_preference = 126;
    break;
  case ICE_CANDIDATE_SRFLX:
    type_preference = 100;
    break;
  case ICE_CANDIDATE_PRFLX:
    type_preference = 110;
    break;
  case ICE_CANDIDATE_RELAY:
    type_preference = 0;
    break;
  default:
    type_preference = 0;
    break;
  }
 
  uint32_t priority =
      (((uint32_t)type_preference) << 24) | (((uint32_t)local_preference) << 8) | (256 - (uint32_t)component_id);
 
  return priority;
}

Referenced by ice_calculate_priority_for_candidate().

ice_calculate_priority_for_candidate()

uint32_t ice_calculate_priority_for_candidate

(

const ice_candidate_t *

candidate

)

Definition at line 136 of file ice.c.

                                                                                {
  if (!candidate) {
    return 0;
  }
 
  // Calculate local preference based on IP classification
  uint16_t local_pref = ice_calculate_local_preference_by_ip(candidate->ip_address);
 
  // Use standard RFC 5245 priority formula with IP-aware local preference
  return ice_calculate_priority(candidate->type, local_pref, (uint8_t)candidate->component_id);
}

References ice_calculate_priority().

ice_candidate_type_name()

const char * ice_candidate_type_name

(

ice_candidate_type_t

type

)

Definition at line 27 of file ice.c.

                                                               {
  switch (type) {
  case ICE_CANDIDATE_HOST:
    return "host";
  case ICE_CANDIDATE_SRFLX:
    return "srflx";
  case ICE_CANDIDATE_PRFLX:
    return "prflx";
  case ICE_CANDIDATE_RELAY:
    return "relay";
  default:
    return "unknown";
  }
}

Referenced by ice_add_remote_candidate(), and ice_format_candidate().

ice_format_candidate()

asciichat_error_t ice_format_candidate	(	const ice_candidate_t *	candidate,
		char *	line,
		size_t	line_size
	)

Definition at line 323 of file ice.c.

                                                                                                       {
  if (!candidate || !line || line_size == 0) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid candidate format parameters");
  }
 
  // Format: foundation component protocol priority ip port typ type [raddr rport] [tcptype type]
  // Example: 1 1 udp 2130706431 192.168.1.1 54321 typ host
  // Example with raddr: 1 1 udp 2130706431 203.0.113.45 54321 typ srflx raddr 192.168.1.1 rport 12345
 
  int written = safe_snprintf(line, line_size, "%s %u %s %u %s %u typ %s", candidate->foundation,
                              candidate->component_id, ice_protocol_name(candidate->protocol), candidate->priority,
                              candidate->ip_address, candidate->port, ice_candidate_type_name(candidate->type));
 
  if (written < 0 || (size_t)written >= line_size) {
    return SET_ERRNO(ERROR_BUFFER_FULL, "Candidate line too large for buffer");
  }
 
  size_t remaining = line_size - (size_t)written;
  char *pos = line + written;
 
  // 2. If srflx/prflx/relay: append raddr and rport
  if (candidate->type == ICE_CANDIDATE_SRFLX || candidate->type == ICE_CANDIDATE_PRFLX ||
      candidate->type == ICE_CANDIDATE_RELAY) {
    if (candidate->raddr[0] != '\0') {
      int appended = safe_snprintf(pos, remaining, " raddr %s rport %u", candidate->raddr, candidate->rport);
      if (appended < 0 || (size_t)appended >= remaining) {
        return SET_ERRNO(ERROR_BUFFER_FULL, "Cannot append raddr/rport to candidate line");
      }
      pos += appended;
      remaining -= (size_t)appended;
    }
  }
 
  // 3. If TCP: append tcptype
  if (candidate->protocol == ICE_PROTOCOL_TCP) {
    const char *tcptype_str = "passive"; // default
    if (candidate->tcp_type == ICE_TCP_TYPE_ACTIVE) {
      tcptype_str = "active";
    } else if (candidate->tcp_type == ICE_TCP_TYPE_SO) {
      tcptype_str = "so";
    }
 
    int appended = safe_snprintf(pos, remaining, " tcptype %s", tcptype_str);
    if (appended < 0 || (size_t)appended >= remaining) {
      return SET_ERRNO(ERROR_BUFFER_FULL, "Cannot append tcptype to candidate line");
    }
    pos += appended;
    remaining -= (size_t)appended;
  }
 
  // 4. Append any extensions
  if (candidate->extensions[0] != '\0') {
    int appended = safe_snprintf(pos, remaining, " %s", candidate->extensions);
    if (appended < 0 || (size_t)appended >= remaining) {
      return SET_ERRNO(ERROR_BUFFER_FULL, "Cannot append extensions to candidate line");
    }
  }
 
  // 5. Ensure line is null-terminated (snprintf already does this)
  return ASCIICHAT_OK;
}

References ice_candidate_type_name(), ice_protocol_name(), and safe_snprintf().

Referenced by ice_add_remote_candidate().

ice_gather_candidates()

asciichat_error_t ice_gather_candidates

(

const ice_config_t *

config

)

Definition at line 389 of file ice.c.

                                                                    {
  if (!config) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid ICE config");
  }
 
  if (!config->send_callback) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "ICE config missing send_callback");
  }
 
  log_debug("ICE: Starting candidate gathering (ufrag=%s, pwd=%s)", config->ufrag, config->pwd);
 
  // NOTE: libdatachannel (juice) handles ICE candidate gathering internally.
  // This function is a placeholder for the callback-based API.
  // The actual gathering happens in the peer_manager when you:
  //   1. Create peer connection with rtcCreatePeerConnection()
  //   2. Set ice candidate callback with rtcSetIceCandidateCallback()
  //   3. libdatachannel automatically gathers candidates from:
  //      - Local interfaces (host candidates)
  //      - STUN servers (server-reflexive candidates)
  //      - TURN servers (relay candidates)
  //   4. When a candidate is found, rtcSetIceCandidateCallback() is called
  //   5. Application (webrtc.c) formats and sends via ACDS signaling
  //
  // This ice_gather_candidates() function may not be called directly -
  // the gathering happens automatically when peer connection is created.
  // Keeping this for API compatibility.
 
  return ASCIICHAT_OK;
}

ice_get_selected_pair()

asciichat_error_t ice_get_selected_pair	(	webrtc_peer_connection_t *	pc,
		ice_candidate_t *	local_candidate,
		ice_candidate_t *	remote_candidate
	)

Definition at line 462 of file ice.c.

                                                                           {
  // Delegate to C++ implementation which uses libdatachannel's C++ API
  return ice_get_selected_pair_impl(pc, local_candidate, remote_candidate);
}

References ice_get_selected_pair_impl().

ice_get_selected_pair_impl()

asciichat_error_t ice_get_selected_pair_impl	(	webrtc_peer_connection_t *	pc,
		ice_candidate_t *	local_candidate,
		ice_candidate_t *	remote_candidate
	)

Get selected ICE candidate pair (C++ implementation)

This function uses libdatachannel's C++ API to retrieve the selected candidate pair, which is not available in the C API.

Definition at line 58 of file ice_selected_pair.cpp.

                                                                                {
  if (!pc) {
    return ERROR_INVALID_PARAM;
  }
 
  try {
    // Get the libdatachannel peer connection ID using helper function
    int rtc_id = webrtc_get_rtc_id(pc);
    if (rtc_id < 0) {
      return ERROR_INVALID_PARAM;
    }
 
    // Query selected candidate pair from libdatachannel
    // Note: This requires libdatachannel to have the selected candidate pair available
    char local_buf[512];
    char remote_buf[512];
 
    // Try to get the selected local candidate
    if (rtcGetSelectedCandidatePair(rtc_id, local_buf, sizeof(local_buf), remote_buf, sizeof(remote_buf)) < 0) {
      // No pair selected yet, or error accessing it
      return ERROR_INVALID_STATE;
    }
 
    // Parse local candidate if requested
    if (local_candidate) {
      std::string local_str(local_buf);
      asciichat_error_t err = parse_datachannel_candidate(local_str, local_candidate);
      if (err != ASCIICHAT_OK) {
        return err;
      }
    }
 
    // Parse remote candidate if requested
    if (remote_candidate) {
      std::string remote_str(remote_buf);
      asciichat_error_t err = parse_datachannel_candidate(remote_str, remote_candidate);
      if (err != ASCIICHAT_OK) {
        return err;
      }
    }
 
    return ASCIICHAT_OK;
 
  } catch (const std::exception &e) {
    return ERROR_NETWORK;
  } catch (...) {
    return ERROR_NETWORK;
  }
}

References webrtc_get_rtc_id().

Referenced by ice_get_selected_pair().

ice_is_connected()

bool ice_is_connected

(

webrtc_peer_connection_t *

pc

)

Definition at line 448 of file ice.c.

                                                    {
  if (!pc) {
    return false;
  }
 
  // Check peer connection state
  webrtc_state_t state = webrtc_get_state(pc);
  return (state == WEBRTC_STATE_CONNECTED);
}

References webrtc_get_state().

ice_parse_candidate()

asciichat_error_t ice_parse_candidate	(	const char *	line,
		ice_candidate_t *	candidate
	)

Definition at line 319 of file ice.c.

                                                                                    {
  return ice_parse_candidate_pcre2(line, candidate);
}

ice_protocol_name()

const char * ice_protocol_name

(

ice_protocol_t

protocol

)

Definition at line 42 of file ice.c.

                                                       {
  switch (protocol) {
  case ICE_PROTOCOL_UDP:
    return "udp";
  case ICE_PROTOCOL_TCP:
    return "tcp";
  default:
    return "unknown";
  }
}

Referenced by ice_format_candidate().