Enum RTCIceTransportPolicy 

pub enum RTCIceTransportPolicy {
    Unspecified = 0,
    All = 1,
    Relay = 2,
}

ICE transport policy controlling which candidate types are used for connectivity.

This policy determines which ICE candidates the peer connection will use and gather during the connection establishment process. It’s primarily used for privacy control and network security requirements.

Privacy Considerations

• All - Exposes local IP addresses (host candidates) and public IPs (srflx)
• Relay - Hides all IP addresses, only TURN server address visible (privacy mode)

Examples

Standard Configuration (All Candidates)

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCIceTransportPolicy};

// Use all candidates for best connectivity (default)
let config = RTCConfigurationBuilder::new()
    .with_ice_transport_policy(RTCIceTransportPolicy::All)
    .build();

Privacy Mode (Relay Only)

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCIceTransportPolicy};
use rtc::peer_connection::configuration::RTCIceServer;

// Only use TURN relays to hide IP addresses
let config = RTCConfigurationBuilder::new()
    .with_ice_servers(vec![
        RTCIceServer {
            urls: vec!["turn:turn.example.com:3478".to_string()],
            username: "user".to_string(),
            credential: "password".to_string(),
            ..Default::default()
        },
    ])
    .with_ice_transport_policy(RTCIceTransportPolicy::Relay)
    .build();

Specifications

• W3C RTCIceTransportPolicy
• RFC 8445 - ICE

Variants

Unspecified = 0

Unspecified - not a valid policy, used as default value

All = 1

Use all types of ICE candidates (recommended for best connectivity).

Gathers and uses:

• Host candidates - Local IP addresses
• Server reflexive (srflx) - Public IP from STUN servers
• Relay candidates - TURN server addresses

This provides the best chance of establishing a connection but may expose local and public IP addresses.

Use when: Normal operation, prioritizing connectivity over privacy

Relay = 2

Only use relay candidates from TURN servers (privacy mode).

Only gathers and uses relay candidates obtained through TURN servers. This hides the client’s IP addresses from the remote peer but requires a TURN server and may reduce connection quality.

Use when: Privacy is critical, IP addresses must be hidden

Requirements: Must have TURN servers configured

Trait Implementations

impl Clone for RTCIceTransportPolicy

fn clone(&self) -> RTCIceTransportPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RTCIceTransportPolicy

impl Debug for RTCIceTransportPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RTCIceTransportPolicy

fn default() -> RTCIceTransportPolicy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RTCIceTransportPolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RTCIceTransportPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for RTCIceTransportPolicy

impl From<&str> for RTCIceTransportPolicy

takes a string and converts it to ICETransportPolicy

fn from(raw: &str) -> Self

Converts to this type from the input type.

impl PartialEq for RTCIceTransportPolicy

fn eq(&self, other: &RTCIceTransportPolicy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RTCIceTransportPolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RTCIceTransportPolicy