@desklink/host 0.5.3 → 0.5.4

package/engine/vendor/rtc-ice/src/candidate/candidate_pair.rs

@@ -0,0 +1,215 @@
+//! Candidate pairs and their check state.
+//!
+//! ICE forms a pair from each compatible local/remote candidate combination and works through
+//! them in priority order. A pair's combined priority is computed from both sides' priorities with
+//! the controlling agent's dominating, so both agents derive the same ordering.
+//!
+//! [`CandidatePairState`](crate::candidate::candidate_pair::CandidatePairState) tracks how far a pair has got: waiting, in progress, succeeded or
+//! failed. The controlling agent nominates one of the succeeded pairs, and that pair carries the
+//! media.
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::time::Duration;
+
+/// Represent the ICE candidate pair state.
+#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[non_exhaustive]
+pub enum CandidatePairState {
+    #[default]
+    #[serde(rename = "unspecified")]
+    /// No state was set.
+    Unspecified = 0,
+
+    /// Means a check has not been performed for this pair.
+    #[serde(rename = "waiting")]
+    Waiting = 1,
+
+    /// Means a check has been sent for this pair, but the transaction is in progress.
+    #[serde(rename = "in-progress")]
+    InProgress = 2,
+
+    /// Means a check for this pair was already done and failed, either never producing any response
+    /// or producing an unrecoverable failure response.
+    #[serde(rename = "failed")]
+    Failed = 3,
+
+    /// Means a check for this pair was already done and produced a successful result.
+    #[serde(rename = "succeeded")]
+    Succeeded = 4,
+}
+
+impl From<u8> for CandidatePairState {
+    fn from(v: u8) -> Self {
+        match v {
+            1 => Self::Waiting,
+            2 => Self::InProgress,
+            3 => Self::Failed,
+            4 => Self::Succeeded,
+            _ => Self::Unspecified,
+        }
+    }
+}
+
+impl fmt::Display for CandidatePairState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            Self::Waiting => "waiting",
+            Self::InProgress => "in-progress",
+            Self::Failed => "failed",
+            Self::Succeeded => "succeeded",
+            Self::Unspecified => "unspecified",
+        };
+
+        write!(f, "{s}")
+    }
+}
+
+/// Represents a combination of a local and remote candidate.
+#[derive(Clone, Copy)]
+pub struct CandidatePair {
+    /// Index of the local candidate in the agent's list.
+    pub local_index: usize,
+    /// Index of the remote candidate in the agent's list.
+    pub remote_index: usize,
+    /// The local candidate's priority.
+    pub local_priority: u32,
+    /// The remote candidate's priority.
+    pub remote_priority: u32,
+    pub(crate) ice_role_controlling: bool,
+    pub(crate) binding_request_count: u16,
+    pub(crate) state: CandidatePairState,
+    pub(crate) nominated: bool,
+
+    // STUN transaction stats
+    /// Total number of STUN connectivity check requests sent (not including retransmissions).
+    pub(crate) requests_sent: u64,
+    /// Total number of STUN connectivity check requests received.
+    pub(crate) requests_received: u64,
+    /// Total number of STUN connectivity check responses sent.
+    pub(crate) responses_sent: u64,
+    /// Total number of STUN connectivity check responses received.
+    pub(crate) responses_received: u64,
+    /// Total number of consent freshness requests sent.
+    pub(crate) consent_requests_sent: u64,
+
+    // RTT tracking
+    /// Sum of all round trip time measurements.
+    pub(crate) total_round_trip_time: Duration,
+    /// Latest round trip time measured.
+    pub(crate) current_round_trip_time: Duration,
+}
+
+impl fmt::Debug for CandidatePair {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "prio {} (local, prio {}) {} <-> {} (remote, prio {})",
+            self.priority(),
+            self.local_priority,
+            self.local_index,
+            self.remote_index,
+            self.remote_priority,
+        )
+    }
+}
+
+impl fmt::Display for CandidatePair {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "prio {} (local, prio {}) {} <-> {} (remote, prio {})",
+            self.priority(),
+            self.local_priority,
+            self.local_index,
+            self.remote_index,
+            self.remote_priority,
+        )
+    }
+}
+
+impl PartialEq for CandidatePair {
+    fn eq(&self, other: &Self) -> bool {
+        self.local_index == other.local_index && self.remote_index == other.remote_index
+    }
+}
+
+impl CandidatePair {
+    #[must_use]
+    /// Forms a pair from a local and a remote candidate.
+    ///
+    /// `controlling` selects which priority dominates in the pair's combined priority.
+    pub fn new(
+        local_index: usize,
+        remote_index: usize,
+        local_priority: u32,
+        remote_priority: u32,
+        ice_role_controlling: bool,
+    ) -> Self {
+        Self {
+            local_index,
+            remote_index,
+            local_priority,
+            remote_priority,
+            ice_role_controlling,
+            state: CandidatePairState::Waiting,
+            binding_request_count: 0,
+            nominated: false,
+            // STUN transaction stats
+            requests_sent: 0,
+            requests_received: 0,
+            responses_sent: 0,
+            responses_received: 0,
+            consent_requests_sent: 0,
+            // RTT tracking
+            total_round_trip_time: Duration::ZERO,
+            current_round_trip_time: Duration::ZERO,
+        }
+    }
+
+    /// RFC 5245 - 5.7.2.  Computing Pair Priority and Ordering Pairs
+    /// Let G be the priority for the candidate provided by the controlling
+    /// agent.  Let D be the priority for the candidate provided by the
+    /// controlled agent.
+    /// pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)
+    pub fn priority(&self) -> u64 {
+        let (g, d) = if self.ice_role_controlling {
+            (self.local_priority, self.remote_priority)
+        } else {
+            (self.remote_priority, self.local_priority)
+        };
+
+        // 1<<32 overflows uint32; and if both g && d are
+        // maxUint32, this result would overflow uint64
+        ((1 << 32_u64) - 1) * u64::from(std::cmp::min(g, d))
+            + 2 * u64::from(std::cmp::max(g, d))
+            + u64::from(g > d)
+    }
+
+    /// Called when a STUN binding request is sent.
+    pub fn on_request_sent(&mut self) {
+        self.requests_sent += 1;
+    }
+
+    /// Called when a STUN binding request is received.
+    pub fn on_request_received(&mut self) {
+        self.requests_received += 1;
+    }
+
+    /// Called when a STUN binding success response is sent.
+    pub fn on_response_sent(&mut self) {
+        self.responses_sent += 1;
+    }
+
+    /// Called when a STUN binding success response is received.
+    /// Also updates RTT measurements.
+    pub fn on_response_received(&mut self, rtt: Duration) {
+        self.responses_received += 1;
+        self.current_round_trip_time = rtt;
+        self.total_round_trip_time += rtt;
+    }
+
+    /// Called when a consent freshness request is sent (keepalive).
+    pub fn on_consent_request_sent(&mut self) {
+        self.consent_requests_sent += 1;
+    }
+}

package/engine/vendor/rtc-ice/src/candidate/candidate_pair_test.rs

@@ -0,0 +1,201 @@
+use super::*;
+use crate::candidate::candidate_host::CandidateHostConfig;
+use crate::candidate::candidate_pair::CandidatePair;
+use crate::candidate::candidate_peer_reflexive::CandidatePeerReflexiveConfig;
+use crate::candidate::candidate_relay::CandidateRelayConfig;
+use crate::candidate::candidate_server_reflexive::CandidateServerReflexiveConfig;
+use crate::candidate::{Candidate, CandidateConfig};
+
+pub(crate) fn host_candidate() -> Result<Candidate> {
+    CandidateHostConfig {
+        base_config: CandidateConfig {
+            network: "udp".to_owned(),
+            address: "0.0.0.0".to_owned(),
+            component: COMPONENT_RTP,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .new_candidate_host()
+}
+
+pub(crate) fn prflx_candidate() -> Result<Candidate> {
+    CandidatePeerReflexiveConfig {
+        base_config: CandidateConfig {
+            network: "udp".to_owned(),
+            address: "0.0.0.0".to_owned(),
+            component: COMPONENT_RTP,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .new_candidate_peer_reflexive()
+}
+
+pub(crate) fn srflx_candidate() -> Result<Candidate> {
+    CandidateServerReflexiveConfig {
+        base_config: CandidateConfig {
+            network: "udp".to_owned(),
+            address: "0.0.0.0".to_owned(),
+            component: COMPONENT_RTP,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .new_candidate_server_reflexive()
+}
+
+pub(crate) fn relay_candidate() -> Result<Candidate> {
+    CandidateRelayConfig {
+        base_config: CandidateConfig {
+            network: "udp".to_owned(),
+            address: "0.0.0.0".to_owned(),
+            component: COMPONENT_RTP,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .new_candidate_relay()
+}
+
+#[test]
+fn test_candidate_pair_priority() -> Result<()> {
+    const HOST_INDEX: usize = 0;
+    const PRFLX_INDEX: usize = 1;
+    const SRFLX_INDEX: usize = 2;
+    const RELAY_INDEX: usize = 3;
+
+    let candidates = vec![
+        host_candidate()?,
+        prflx_candidate()?,
+        srflx_candidate()?,
+        relay_candidate()?,
+    ];
+
+    let tests = vec![
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                HOST_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[HOST_INDEX].priority(),
+                false,
+            ),
+            9151314440652587007,
+        ),
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                HOST_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[HOST_INDEX].priority(),
+                true,
+            ),
+            9151314440652587007,
+        ),
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                PRFLX_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[PRFLX_INDEX].priority(),
+                true,
+            ),
+            7998392936314175488,
+        ),
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                PRFLX_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[PRFLX_INDEX].priority(),
+                false,
+            ),
+            7998392936314175487,
+        ),
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                SRFLX_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[SRFLX_INDEX].priority(),
+                true,
+            ),
+            7277816996102668288,
+        ),
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                SRFLX_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[SRFLX_INDEX].priority(),
+                false,
+            ),
+            7277816996102668287,
+        ),
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                RELAY_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[RELAY_INDEX].priority(),
+                true,
+            ),
+            72057593987596288,
+        ),
+        (
+            CandidatePair::new(
+                HOST_INDEX,
+                RELAY_INDEX,
+                candidates[HOST_INDEX].priority(),
+                candidates[RELAY_INDEX].priority(),
+                false,
+            ),
+            72057593987596287,
+        ),
+    ];
+
+    for (pair, want) in tests {
+        let got = pair.priority();
+        assert_eq!(
+            got, want,
+            "CandidatePair({pair}).Priority() = {got}, want {want}"
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_candidate_pair_equality() -> Result<()> {
+    const HOST_INDEX: usize = 0;
+    const PRFLX_INDEX: usize = 1;
+    const SRFLX_INDEX: usize = 2;
+    const RELAY_INDEX: usize = 3;
+
+    let candidates = vec![
+        host_candidate()?,
+        prflx_candidate()?,
+        srflx_candidate()?,
+        relay_candidate()?,
+    ];
+
+    let pair_a = CandidatePair::new(
+        HOST_INDEX,
+        SRFLX_INDEX,
+        candidates[HOST_INDEX].priority(),
+        candidates[SRFLX_INDEX].priority(),
+        true,
+    );
+    let pair_b = CandidatePair::new(
+        HOST_INDEX,
+        SRFLX_INDEX,
+        candidates[HOST_INDEX].priority(),
+        candidates[SRFLX_INDEX].priority(),
+        false,
+    );
+
+    assert_eq!(pair_a, pair_b, "Expected {pair_a} to equal {pair_b}");
+
+    Ok(())
+}

package/engine/vendor/rtc-ice/src/candidate/candidate_peer_reflexive.rs

@@ -0,0 +1,49 @@
+use super::*;
+use crate::network_type::determine_network_type;
+use crate::rand::generate_cand_id;
+use shared::error::*;
+
+/// The config required to create a new `CandidatePeerReflexive`.
+#[derive(Default)]
+pub struct CandidatePeerReflexiveConfig {
+    /// The fields shared by every candidate type.
+    pub base_config: CandidateConfig,
+
+    /// The base address this candidate was derived from, reported as `raddr`.
+    pub rel_addr: String,
+    /// The base port, reported as `rport`.
+    pub rel_port: u16,
+}
+
+impl CandidatePeerReflexiveConfig {
+    /// Creates a new peer reflective candidate.
+    pub fn new_candidate_peer_reflexive(self) -> Result<Candidate> {
+        let mut candidate_id = self.base_config.candidate_id;
+        if candidate_id.is_empty() {
+            candidate_id = generate_cand_id();
+        }
+
+        let ip: IpAddr = match self.base_config.address.parse() {
+            Ok(ip) => ip,
+            Err(_) => return Err(Error::ErrAddressParseFailed),
+        };
+        let network_type = determine_network_type(&self.base_config.network, &ip)?;
+
+        Ok(Candidate {
+            id: candidate_id,
+            network_type,
+            candidate_type: CandidateType::PeerReflexive,
+            address: self.base_config.address,
+            port: self.base_config.port,
+            resolved_addr: SocketAddr::new(ip, self.base_config.port),
+            component: self.base_config.component,
+            foundation_override: self.base_config.foundation,
+            priority_override: self.base_config.priority,
+            related_address: Some(CandidateRelatedAddress {
+                address: self.rel_addr,
+                port: self.rel_port,
+            }),
+            ..Candidate::default()
+        })
+    }
+}

package/engine/vendor/rtc-ice/src/candidate/candidate_relay.rs

@@ -0,0 +1,53 @@
+use super::*;
+use crate::network_type::determine_network_type;
+use crate::rand::generate_cand_id;
+use shared::error::*;
+
+/// The config required to create a new `CandidateRelay`.
+#[derive(Default)]
+pub struct CandidateRelayConfig {
+    /// The fields shared by every candidate type.
+    pub base_config: CandidateConfig,
+
+    /// The base address this candidate was derived from, reported as `raddr`.
+    pub rel_addr: String,
+    /// The base port, reported as `rport`.
+    pub rel_port: u16,
+
+    /// The server this candidate was gathered from.
+    pub url: Option<String>,
+}
+
+impl CandidateRelayConfig {
+    /// Creates a new relay candidate.
+    pub fn new_candidate_relay(self) -> Result<Candidate> {
+        let mut candidate_id = self.base_config.candidate_id;
+        if candidate_id.is_empty() {
+            candidate_id = generate_cand_id();
+        }
+
+        let ip: IpAddr = match self.base_config.address.parse() {
+            Ok(ip) => ip,
+            Err(_) => return Err(Error::ErrAddressParseFailed),
+        };
+        let network_type = determine_network_type(&self.base_config.network, &ip)?;
+
+        Ok(Candidate {
+            id: candidate_id,
+            network_type,
+            candidate_type: CandidateType::Relay,
+            address: self.base_config.address,
+            port: self.base_config.port,
+            resolved_addr: SocketAddr::new(ip, self.base_config.port),
+            component: self.base_config.component,
+            foundation_override: self.base_config.foundation,
+            priority_override: self.base_config.priority,
+            related_address: Some(CandidateRelatedAddress {
+                address: self.rel_addr,
+                port: self.rel_port,
+            }),
+            url: self.url,
+            ..Candidate::default()
+        })
+    }
+}

package/engine/vendor/rtc-ice/src/candidate/candidate_relay_test.rs

@@ -0,0 +1,114 @@
+use std::result::Result;
+use std::time::Duration;
+
+use tokio::net::UdpSocket;
+use turn::auth::AuthHandler;
+
+use super::*;
+use crate::agent::agent_config::AgentConfig;
+use crate::agent::agent_vnet_test::{connect_with_vnet, on_connected};
+use crate::agent::Agent;
+use crate::error::Error;
+use crate::url::{ProtoType, SchemeType, Url};
+
+pub(crate) struct OptimisticAuthHandler;
+
+impl AuthHandler for OptimisticAuthHandler {
+    fn auth_handle(
+        &self,
+        _username: &str,
+        _realm: &str,
+        _src_addr: SocketAddr,
+    ) -> Result<Vec<u8>, turn::Error> {
+        Ok(turn::auth::generate_auth_key(
+            "username",
+            "webrtc.rs",
+            "password",
+        ))
+    }
+}
+
+//use std::io::Write;
+
+#[tokio::test]
+async fn test_relay_only_connection() -> Result<(), Error> {
+    /*env_logger::Builder::new()
+    .format(|buf, record| {
+        writeln!(
+            buf,
+            "{}:{} [{}] {} - {}",
+            record.file().unwrap_or("unknown"),
+            record.line().unwrap_or(0),
+            record.level(),
+            chrono::Local::now().format("%H:%M:%S.%6f"),
+            record.args()
+        )
+    })
+    .filter(None, LevelFilter::Trace)
+    .init();*/
+
+    let server_listener = Arc::new(UdpSocket::bind("127.0.0.1:0").await?);
+    let server_port = server_listener.local_addr()?.port();
+
+    let server = turn::server::Server::new(turn::server::config::ServerConfig {
+        realm: "webrtc.rs".to_owned(),
+        auth_handler: Arc::new(OptimisticAuthHandler {}),
+        conn_configs: vec![turn::server::config::ConnConfig {
+            conn: server_listener,
+            relay_addr_generator: Box::new(turn::relay::relay_none::RelayAddressGeneratorNone {
+                address: "127.0.0.1".to_owned(),
+                net: Arc::new(util::vnet::net::Net::new(None)),
+            }),
+        }],
+        channel_bind_timeout: Duration::from_secs(0),
+        alloc_close_notify: None,
+    })
+    .await?;
+
+    let cfg0 = AgentConfig {
+        network_types: supported_network_types(),
+        urls: vec![Url {
+            scheme: SchemeType::Turn,
+            host: "127.0.0.1".to_owned(),
+            username: "username".to_owned(),
+            password: "password".to_owned(),
+            port: server_port,
+            proto: ProtoType::Udp,
+        }],
+        candidate_types: vec![CandidateType::Relay],
+        ..Default::default()
+    };
+
+    let a_agent = Arc::new(Agent::new(cfg0).await?);
+    let (a_notifier, mut a_connected) = on_connected();
+    a_agent.on_connection_state_change(a_notifier);
+
+    let cfg1 = AgentConfig {
+        network_types: supported_network_types(),
+        urls: vec![Url {
+            scheme: SchemeType::Turn,
+            host: "127.0.0.1".to_owned(),
+            username: "username".to_owned(),
+            password: "password".to_owned(),
+            port: server_port,
+            proto: ProtoType::Udp,
+        }],
+        candidate_types: vec![CandidateType::Relay],
+        ..Default::default()
+    };
+
+    let b_agent = Arc::new(Agent::new(cfg1).await?);
+    let (b_notifier, mut b_connected) = on_connected();
+    b_agent.on_connection_state_change(b_notifier);
+
+    connect_with_vnet(&a_agent, &b_agent).await?;
+
+    let _ = a_connected.recv().await;
+    let _ = b_connected.recv().await;
+
+    a_agent.close().await?;
+    b_agent.close().await?;
+    server.close().await?;
+
+    Ok(())
+}

package/engine/vendor/rtc-ice/src/candidate/candidate_server_reflexive.rs

@@ -0,0 +1,53 @@
+use super::*;
+use crate::network_type::determine_network_type;
+use crate::rand::generate_cand_id;
+use shared::error::*;
+
+/// The config required to create a new `CandidateServerReflexive`.
+#[derive(Default)]
+pub struct CandidateServerReflexiveConfig {
+    /// The fields shared by every candidate type.
+    pub base_config: CandidateConfig,
+
+    /// The base address this candidate was derived from, reported as `raddr`.
+    pub rel_addr: String,
+    /// The base port, reported as `rport`.
+    pub rel_port: u16,
+
+    /// The server this candidate was gathered from.
+    pub url: Option<String>,
+}
+
+impl CandidateServerReflexiveConfig {
+    /// Creates a new server reflective candidate.
+    pub fn new_candidate_server_reflexive(self) -> Result<Candidate> {
+        let mut candidate_id = self.base_config.candidate_id;
+        if candidate_id.is_empty() {
+            candidate_id = generate_cand_id();
+        }
+
+        let ip: IpAddr = match self.base_config.address.parse() {
+            Ok(ip) => ip,
+            Err(_) => return Err(Error::ErrAddressParseFailed),
+        };
+        let network_type = determine_network_type(&self.base_config.network, &ip)?;
+
+        Ok(Candidate {
+            id: candidate_id,
+            network_type,
+            candidate_type: CandidateType::ServerReflexive,
+            address: self.base_config.address,
+            port: self.base_config.port,
+            resolved_addr: SocketAddr::new(ip, self.base_config.port),
+            component: self.base_config.component,
+            foundation_override: self.base_config.foundation,
+            priority_override: self.base_config.priority,
+            related_address: Some(CandidateRelatedAddress {
+                address: self.rel_addr,
+                port: self.rel_port,
+            }),
+            url: self.url,
+            ..Candidate::default()
+        })
+    }
+}