@desklink/host 0.5.3 → 0.5.4

package/engine/vendor/rtc-ice/src/lib.rs

@@ -0,0 +1,85 @@
+#![warn(rust_2018_idioms)]
+#![warn(missing_docs)]
+#![allow(dead_code)]
+
+//! ICE for the Sans-I/O WebRTC stack.
+//!
+//! Interactive Connectivity Establishment ([RFC 8445], superseding [RFC 5245]) with the
+//! extensions WebRTC uses: ICE-TCP candidates ([RFC 6544]), consent freshness
+//! ([RFC 7675]), and Trickle ICE. ICE is what finds a path between two peers behind NATs:
+//! it gathers candidate addresses, pairs local with remote, and probes each pair with STUN
+//! connectivity checks until one succeeds.
+//!
+//! # Structure
+//!
+//! * [`agent`] — the Sans-I/O [`Agent`]: give it candidates and inbound
+//!   datagrams, poll it for checks to send, state transitions, and the selected pair. It
+//!   owns no sockets and no clock.
+//! * [`candidate`] — the candidate types (host, server-reflexive, peer-reflexive, relay),
+//!   their priorities, and SDP `a=candidate` parsing.
+//! * [`state`] — connection and gathering states, and the checklist state machine.
+//! * [`url`] — parsing `stun:`/`turn:` server URLs into something the agent can gather from.
+//! * [`network_type`], [`tcp_type`] — UDP/TCP and active/passive/simultaneous-open.
+//! * [`stats`] — per-candidate and per-pair counters, surfaced through `getStats`.
+//! * [`mdns`] — mDNS candidate handling, for hiding private addresses.
+//!
+//! # Example
+//!
+//! ```
+//! use rtc_ice::url::{ProtoType, SchemeType, Url};
+//!
+//! # fn example() -> Result<(), Box<dyn std::error::Error>> {
+//! let stun = Url::parse_url("stun:stun.l.google.com:19302")?;
+//! assert_eq!(stun.scheme, SchemeType::Stun);
+//! assert_eq!(stun.port, 19302);
+//!
+//! // TURN URLs may pin the transport used to reach the server.
+//! let turn = Url::parse_url("turn:turn.example.com:3478?transport=tcp")?;
+//! assert_eq!(turn.scheme, SchemeType::Turn);
+//! assert_eq!(turn.proto, ProtoType::Tcp);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! Most applications do not depend on this crate directly — the
+//! [`rtc`](https://docs.rs/rtc) crate drives the agent as one layer of the peer-connection
+//! pipeline.
+//!
+//! [RFC 8445]: https://datatracker.ietf.org/doc/html/rfc8445
+//! [RFC 5245]: https://datatracker.ietf.org/doc/html/rfc5245
+//! [RFC 6544]: https://datatracker.ietf.org/doc/html/rfc6544
+//! [RFC 7675]: https://datatracker.ietf.org/doc/html/rfc7675
+
+/// The Sans-I/O ICE agent: candidate pairing, connectivity checks, and nomination.
+/// The crypto provider API.
+///
+/// Re-exported because this crate's public constructors take an
+/// [`Arc<dyn RTCCryptoProvider>`](crypto::RTCCryptoProvider), which a caller must be able to name
+/// without adding — and version-matching — a direct `rtc-crypto` dependency.
+pub use crypto;
+
+pub mod agent;
+/// The ICE-specific STUN attributes carried in connectivity checks.
+pub mod attributes;
+/// Candidate types, priorities, and SDP `a=candidate` parsing.
+pub mod candidate;
+/// mDNS candidate handling, which hides private addresses behind `.local` names.
+pub mod mdns;
+/// UDP/TCP over IPv4/IPv6, as a candidate's transport.
+pub mod network_type;
+/// Random ICE credentials and identifiers.
+pub mod rand;
+/// Connection and gathering states.
+pub mod state;
+/// Per-candidate and per-pair counters, surfaced through `getStats`.
+pub mod stats;
+/// Active, passive and simultaneous-open, for ICE-TCP candidates.
+pub mod tcp_type;
+/// Parsing `stun:`/`turn:` server URLs.
+pub mod url;
+
+pub use agent::{
+    Agent, Credentials, Event,
+    agent_config::AgentConfig,
+    agent_stats::{CandidatePairStats, CandidateStats},
+};

package/engine/vendor/rtc-ice/src/mdns/mdns_test.rs

@@ -0,0 +1,150 @@
+use regex::Regex;
+use tokio::sync::{Mutex, mpsc};
+
+use super::*;
+use crate::agent::agent_config::*;
+use crate::agent::*;
+use crate::candidate::*;
+use crate::network_type::*;
+use shared::error::Error;
+
+#[tokio::test]
+// This test is disabled on Windows for now because it gets stuck and never finishes.
+// This does not seem to have happened due to a code change. It started happening with
+// `ce55c3a066ab461c3e74f0d5ac6f1209205e79bc` but was verified as happening on
+// `92cc698a3dc6da459f3bf3789fd046c2dffdf107` too.
+#[cfg(not(windows))]
+async fn test_multicast_dns_only_connection() -> Result<()> {
+    let cfg0 = AgentConfig {
+        network_types: vec![NetworkType::Udp4],
+        candidate_types: vec![CandidateType::Host],
+        multicast_dns_mode: MulticastDnsMode::QueryAndGather,
+        ..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: vec![NetworkType::Udp4],
+        candidate_types: vec![CandidateType::Host],
+        multicast_dns_mode: MulticastDnsMode::QueryAndGather,
+        ..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?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_multicast_dns_mixed_connection() -> Result<()> {
+    let cfg0 = AgentConfig {
+        network_types: vec![NetworkType::Udp4],
+        candidate_types: vec![CandidateType::Host],
+        multicast_dns_mode: MulticastDnsMode::QueryAndGather,
+        ..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: vec![NetworkType::Udp4],
+        candidate_types: vec![CandidateType::Host],
+        multicast_dns_mode: MulticastDnsMode::QueryOnly,
+        ..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?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_multicast_dns_static_host_name() -> Result<()> {
+    let cfg0 = AgentConfig {
+        network_types: vec![NetworkType::Udp4],
+        candidate_types: vec![CandidateType::Host],
+        multicast_dns_mode: MulticastDnsMode::QueryAndGather,
+        multicast_dns_host_name: "invalidHostName".to_owned(),
+        ..Default::default()
+    };
+    if let Err(err) = Agent::new(cfg0).await {
+        assert_eq!(err, Error::ErrInvalidMulticastDnshostName);
+    } else {
+        panic!("expected error, but got ok");
+    }
+
+    let cfg1 = AgentConfig {
+        network_types: vec![NetworkType::Udp4],
+        candidate_types: vec![CandidateType::Host],
+        multicast_dns_mode: MulticastDnsMode::QueryAndGather,
+        multicast_dns_host_name: "validName.local".to_owned(),
+        ..Default::default()
+    };
+
+    let a = Agent::new(cfg1).await?;
+
+    let (done_tx, mut done_rx) = mpsc::channel::<()>(1);
+    let done_tx = Arc::new(Mutex::new(Some(done_tx)));
+    a.on_candidate(Box::new(
+        move |c: Option<Arc<dyn Candidate + Send + Sync>>| {
+            let done_tx_clone = Arc::clone(&done_tx);
+            Box::pin(async move {
+                if c.is_none() {
+                    let mut tx = done_tx_clone.lock().await;
+                    tx.take();
+                }
+            })
+        },
+    ));
+
+    a.gather_candidates()?;
+
+    log::debug!("wait for gathering is done...");
+    let _ = done_rx.recv().await;
+    log::debug!("gathering is done");
+
+    Ok(())
+}
+
+#[test]
+fn test_generate_multicast_dnsname() -> Result<()> {
+    let name = generate_multicast_dns_name();
+
+    let re = Regex::new(
+        r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}.local+$",
+    );
+
+    if let Ok(re) = re {
+        assert!(
+            re.is_match(&name),
+            "mDNS name must be UUID v4 + \".local\" suffix, got {name}"
+        );
+    } else {
+        panic!("expected ok, but got err");
+    }
+
+    Ok(())
+}

package/engine/vendor/rtc-ice/src/mdns/mod.rs

@@ -0,0 +1,69 @@
+//#[cfg(test)]
+//mod mdns_test;
+
+use mdns::Mdns;
+use mdns::MdnsConfig;
+use std::net::{IpAddr, Ipv4Addr};
+use std::time::{Duration, Instant};
+use uuid::Uuid;
+
+use shared::error::Result;
+
+/// Represents the different Multicast modes that ICE can run.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+#[non_exhaustive]
+pub enum MulticastDnsMode {
+    /// Means remote mDNS candidates will be discarded, and local host candidates will use IPs.
+    Disabled,
+
+    /// Means remote mDNS candidates will be accepted, and local host candidates will use IPs.
+    #[default]
+    QueryOnly,
+
+    /// Means remote mDNS candidates will be accepted, and local host candidates will use mDNS.
+    QueryAndGather,
+}
+
+pub(crate) fn generate_multicast_dns_name() -> String {
+    // https://tools.ietf.org/id/draft-ietf-rtcweb-mdns-ice-candidates-02.html#gathering
+    // The unique name MUST consist of a version 4 UUID as defined in [RFC4122], followed by “.local”.
+    // This is a short-lived privacy alias, not a credential. `Uuid::new_v4` obtains randomness
+    // from the UUID crate's secure random source without forcing provider ownership into mDNS.
+    let u = Uuid::new_v4();
+    format!("{u}.local")
+}
+
+pub(crate) fn create_multicast_dns(
+    now: Instant,
+    mdns_mode: MulticastDnsMode,
+    mdns_local_name: &str,
+    mdns_local_ip: &Option<IpAddr>,
+    mdns_query_timeout: &Option<Duration>,
+) -> Result<Option<Mdns>> {
+    if mdns_mode == MulticastDnsMode::Disabled {
+        return Ok(None);
+    }
+
+    let mut config = if mdns_mode == MulticastDnsMode::QueryAndGather {
+        let local_ip = if let Some(local_ip) = mdns_local_ip {
+            *local_ip
+        } else {
+            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))
+        };
+        log::info!("mDNS is using {local_ip} as local ip");
+
+        MdnsConfig::new()
+            .with_local_names(vec![mdns_local_name.to_owned()])
+            .with_local_ip(local_ip)
+    } else {
+        MdnsConfig::new()
+    };
+
+    if let Some(query_timeout) = mdns_query_timeout {
+        config = config.with_query_timeout(*query_timeout);
+    }
+
+    let mdns_server = Mdns::new(now, config);
+
+    Ok(Some(mdns_server))
+}

package/engine/vendor/rtc-ice/src/network_type/mod.rs

@@ -0,0 +1,162 @@
+//! Candidate transports: UDP or TCP, over IPv4 or IPv6.
+//!
+//! A [`NetworkType`](crate::network_type::NetworkType) pairs the transport protocol with the address family, because ICE treats
+//! them together: a candidate's type constrains which remote candidates it can be paired with,
+//! and pairs across families are never formed.
+#[cfg(test)]
+mod network_type_test;
+
+use std::fmt;
+use std::net::IpAddr;
+
+use serde::{Deserialize, Serialize};
+
+use shared::TransportProtocol;
+use shared::error::*;
+
+pub(crate) const UDP: &str = "udp";
+pub(crate) const TCP: &str = "tcp";
+
+#[must_use]
+/// Every network type this crate can gather candidates for.
+pub fn supported_network_types() -> Vec<NetworkType> {
+    vec![
+        NetworkType::Udp4,
+        NetworkType::Udp6,
+        NetworkType::Tcp4,
+        NetworkType::Tcp6,
+    ]
+}
+
+/// Represents the type of network.
+#[derive(Default, PartialEq, Debug, Copy, Clone, Eq, Hash, Serialize, Deserialize)]
+#[non_exhaustive]
+pub enum NetworkType {
+    #[serde(rename = "unspecified")]
+    #[default]
+    /// No network type was set.
+    Unspecified,
+
+    /// Indicates UDP over IPv4.
+    #[serde(rename = "udp4")]
+    Udp4,
+
+    /// Indicates UDP over IPv6.
+    #[serde(rename = "udp6")]
+    Udp6,
+
+    /// Indicates TCP over IPv4.
+    #[serde(rename = "tcp4")]
+    Tcp4,
+
+    /// Indicates TCP over IPv6.
+    #[serde(rename = "tcp6")]
+    Tcp6,
+}
+
+impl From<u8> for NetworkType {
+    fn from(v: u8) -> Self {
+        match v {
+            1 => Self::Udp4,
+            2 => Self::Udp6,
+            3 => Self::Tcp4,
+            4 => Self::Tcp6,
+            _ => Self::Unspecified,
+        }
+    }
+}
+
+impl fmt::Display for NetworkType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            Self::Udp4 => "udp4",
+            Self::Udp6 => "udp6",
+            Self::Tcp4 => "tcp4",
+            Self::Tcp6 => "tcp6",
+            Self::Unspecified => "unspecified",
+        };
+        write!(f, "{s}")
+    }
+}
+
+impl NetworkType {
+    /// Returns true when network is UDP4 or UDP6.
+    #[must_use]
+    pub fn is_udp(self) -> bool {
+        self == Self::Udp4 || self == Self::Udp6
+    }
+
+    /// Returns true when network is TCP4 or TCP6.
+    #[must_use]
+    pub fn is_tcp(self) -> bool {
+        self == Self::Tcp4 || self == Self::Tcp6
+    }
+
+    #[must_use]
+    /// The transport protocol, discarding the address family.
+    pub fn to_protocol(self) -> TransportProtocol {
+        if self.is_tcp() {
+            TransportProtocol::TCP
+        } else {
+            TransportProtocol::UDP
+        }
+    }
+
+    /// Returns the short network description.
+    #[must_use]
+    pub fn network_short(self) -> String {
+        match self {
+            Self::Udp4 | Self::Udp6 => UDP.to_owned(),
+            Self::Tcp4 | Self::Tcp6 => TCP.to_owned(),
+            Self::Unspecified => "Unspecified".to_owned(),
+        }
+    }
+
+    /// Returns true if the network is reliable.
+    #[must_use]
+    pub const fn is_reliable(self) -> bool {
+        match self {
+            Self::Tcp4 | Self::Tcp6 => true,
+            Self::Udp4 | Self::Udp6 | Self::Unspecified => false,
+        }
+    }
+
+    /// Returns whether the network type is IPv4 or not.
+    #[must_use]
+    pub const fn is_ipv4(self) -> bool {
+        match self {
+            Self::Udp4 | Self::Tcp4 => true,
+            Self::Udp6 | Self::Tcp6 | Self::Unspecified => false,
+        }
+    }
+
+    /// Returns whether the network type is IPv6 or not.
+    #[must_use]
+    pub const fn is_ipv6(self) -> bool {
+        match self {
+            Self::Udp6 | Self::Tcp6 => true,
+            Self::Udp4 | Self::Tcp4 | Self::Unspecified => false,
+        }
+    }
+}
+
+/// Determines the type of network based on the short network string and an IP address.
+pub(crate) fn determine_network_type(network: &str, ip: &IpAddr) -> Result<NetworkType> {
+    let ipv4 = ip.is_ipv4();
+    let net = network.to_lowercase();
+    if net.starts_with(UDP) {
+        if ipv4 {
+            Ok(NetworkType::Udp4)
+        } else {
+            Ok(NetworkType::Udp6)
+        }
+    } else if net.starts_with(TCP) {
+        if ipv4 {
+            Ok(NetworkType::Tcp4)
+        } else {
+            Ok(NetworkType::Tcp6)
+        }
+    } else {
+        Err(Error::ErrDetermineNetworkType)
+    }
+}

package/engine/vendor/rtc-ice/src/network_type/network_type_test.rs

@@ -0,0 +1,95 @@
+use super::*;
+use shared::error::Result;
+
+#[test]
+fn test_network_type_parsing_success() -> Result<()> {
+    let ipv4: IpAddr = "192.168.0.1".parse().unwrap();
+    let ipv6: IpAddr = "fe80::a3:6ff:fec4:5454".parse().unwrap();
+
+    let tests = vec![
+        ("lowercase UDP4", "udp", ipv4, NetworkType::Udp4),
+        ("uppercase UDP4", "UDP", ipv4, NetworkType::Udp4),
+        ("lowercase UDP6", "udp", ipv6, NetworkType::Udp6),
+        ("uppercase UDP6", "UDP", ipv6, NetworkType::Udp6),
+    ];
+
+    for (name, in_network, in_ip, expected) in tests {
+        let actual = determine_network_type(in_network, &in_ip)?;
+
+        assert_eq!(
+            actual, expected,
+            "NetworkTypeParsing: '{name}' -- input:{in_network} expected:{expected} actual:{actual}"
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_network_type_parsing_failure() -> Result<()> {
+    let ipv6: IpAddr = "fe80::a3:6ff:fec4:5454".parse().unwrap();
+
+    let tests = vec![("invalid network", "junkNetwork", ipv6)];
+    for (name, in_network, in_ip) in tests {
+        let result = determine_network_type(in_network, &in_ip);
+        assert!(
+            result.is_err(),
+            "NetworkTypeParsing should fail: '{name}' -- input:{in_network}",
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_network_type_is_udp() -> Result<()> {
+    assert!(NetworkType::Udp4.is_udp());
+    assert!(NetworkType::Udp6.is_udp());
+    assert!(!NetworkType::Udp4.is_tcp());
+    assert!(!NetworkType::Udp6.is_tcp());
+
+    Ok(())
+}
+
+#[test]
+fn test_network_type_is_tcp() -> Result<()> {
+    assert!(NetworkType::Tcp4.is_tcp());
+    assert!(NetworkType::Tcp6.is_tcp());
+    assert!(!NetworkType::Tcp4.is_udp());
+    assert!(!NetworkType::Tcp6.is_udp());
+
+    Ok(())
+}
+
+#[test]
+fn test_network_type_serialization() {
+    let tests = vec![
+        (NetworkType::Tcp4, "\"tcp4\""),
+        (NetworkType::Tcp6, "\"tcp6\""),
+        (NetworkType::Udp4, "\"udp4\""),
+        (NetworkType::Udp6, "\"udp6\""),
+        (NetworkType::Unspecified, "\"unspecified\""),
+    ];
+
+    for (network_type, expected_string) in tests {
+        assert_eq!(
+            expected_string.to_string(),
+            serde_json::to_string(&network_type).unwrap()
+        );
+    }
+}
+
+#[test]
+fn test_network_type_to_string() {
+    let tests = vec![
+        (NetworkType::Tcp4, "tcp4"),
+        (NetworkType::Tcp6, "tcp6"),
+        (NetworkType::Udp4, "udp4"),
+        (NetworkType::Udp6, "udp6"),
+        (NetworkType::Unspecified, "unspecified"),
+    ];
+
+    for (network_type, expected_string) in tests {
+        assert_eq!(network_type.to_string(), expected_string);
+    }
+}

package/engine/vendor/rtc-ice/src/rand/mod.rs

@@ -0,0 +1,91 @@
+use crypto::RTCRandom;
+use shared::error::{Error, Result};
+use shared::util::generate_crypto_random_string;
+
+#[cfg(test)]
+mod rand_test;
+
+const RUNES_ALPHA: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const RUNES_CANDIDATE_ID_FOUNDATION: &[u8] =
+    b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/+";
+
+const LEN_UFRAG: usize = 16;
+const LEN_PWD: usize = 32;
+
+/// <https://tools.ietf.org/html/rfc5245#section-15.1>
+/// candidate-id = "candidate" ":" foundation
+/// foundation   = 1*32ice-char
+/// ice-char     = ALPHA / DIGIT / "+" / "/"
+///
+/// Candidate IDs provide local uniqueness and diagnostics; they are not credentials or
+/// cryptographic identities. This standalone helper therefore uses `rand`'s thread-local CSPRNG
+/// rather than requiring a crypto provider.
+pub fn generate_cand_id() -> String {
+    format!(
+        "candidate:{}",
+        generate_crypto_random_string(32, RUNES_CANDIDATE_ID_FOUNDATION)
+    )
+}
+
+fn generate_string_with_random(
+    length: usize,
+    alphabet: &[u8],
+    random: &dyn RTCRandom,
+) -> Result<String> {
+    debug_assert!(!alphabet.is_empty() && alphabet.len() <= u8::MAX as usize + 1);
+
+    let acceptance_limit = 256 - (256 % alphabet.len());
+    let mut output = String::with_capacity(length);
+    let mut random_bytes = [0_u8; 64];
+    while output.len() < length {
+        random
+            .fill(&mut random_bytes)
+            .map_err(|error| Error::Crypto(error.to_string()))?;
+        for byte in random_bytes {
+            if byte as usize >= acceptance_limit {
+                continue;
+            }
+            output.push(alphabet[byte as usize % alphabet.len()] as char);
+            if output.len() == length {
+                break;
+            }
+        }
+    }
+    Ok(output)
+}
+
+/// Generates an ICE password with `rand`'s thread-local CSPRNG.
+///
+/// ICE agents use the provider-backed internal variant. This function remains as a standalone
+/// compatibility helper for callers that do not own an [`crypto::RTCCryptoProvider`].
+pub fn generate_pwd() -> String {
+    generate_crypto_random_string(LEN_PWD, RUNES_ALPHA)
+}
+
+/// Generates an ICE password using an explicitly supplied cryptographically secure random source.
+pub(crate) fn generate_pwd_with_random(random: &dyn RTCRandom) -> Result<String> {
+    generate_string_with_random(LEN_PWD, RUNES_ALPHA, random)
+}
+
+/// Generates the 64-bit ICE role-conflict tie breaker from the agent's random provider.
+pub(crate) fn generate_tie_breaker(random: &dyn RTCRandom) -> Result<u64> {
+    let mut bytes = [0_u8; std::mem::size_of::<u64>()];
+    random
+        .fill(&mut bytes)
+        .map_err(|error| Error::Crypto(error.to_string()))?;
+    Ok(u64::from_be_bytes(bytes))
+}
+
+/// Generates an ICE username fragment with `rand`'s thread-local CSPRNG.
+///
+/// ICE agents use the provider-backed internal variant. This function remains as a standalone
+/// compatibility helper for callers that do not own an [`crypto::RTCCryptoProvider`].
+pub fn generate_ufrag() -> String {
+    generate_crypto_random_string(LEN_UFRAG, RUNES_ALPHA)
+}
+
+/// Generates an ICE username fragment using an explicitly supplied cryptographically secure random
+/// source.
+pub(crate) fn generate_ufrag_with_random(random: &dyn RTCRandom) -> Result<String> {
+    generate_string_with_random(LEN_UFRAG, RUNES_ALPHA, random)
+}