@desklink/host 0.5.3 → 0.5.6

package/engine/vendor/rtc-ice/src/agent/agent_config.rs

@@ -0,0 +1,126 @@
+use std::net::IpAddr;
+use std::time::Duration;
+
+use super::*;
+use crate::mdns::*;
+use crate::network_type::NetworkType;
+use crate::url::*;
+
+/// The interval at which the agent performs candidate checks in the connecting phase.
+pub(crate) const DEFAULT_CHECK_INTERVAL: Duration = Duration::from_millis(200);
+
+/// The interval used to keep candidates alive.
+pub(crate) const DEFAULT_KEEPALIVE_INTERVAL: Duration = Duration::from_secs(2);
+
+/// The default time till an Agent transitions disconnected.
+pub(crate) const DEFAULT_DISCONNECTED_TIMEOUT: Duration = Duration::from_secs(5);
+
+/// The default time till an Agent transitions to failed after disconnected.
+pub(crate) const DEFAULT_FAILED_TIMEOUT: Duration = Duration::from_secs(25);
+
+/// Wait time before nominating a host candidate.
+pub(crate) const DEFAULT_HOST_ACCEPTANCE_MIN_WAIT: Duration = Duration::from_secs(0);
+
+/// Wait time before nominating a srflx candidate.
+pub(crate) const DEFAULT_SRFLX_ACCEPTANCE_MIN_WAIT: Duration = Duration::from_millis(500);
+
+/// Wait time before nominating a prflx candidate.
+pub(crate) const DEFAULT_PRFLX_ACCEPTANCE_MIN_WAIT: Duration = Duration::from_millis(1000);
+
+/// Wait time before nominating a relay candidate.
+pub(crate) const DEFAULT_RELAY_ACCEPTANCE_MIN_WAIT: Duration = Duration::from_millis(2000);
+
+/// Max binding request before considering a pair failed.
+pub(crate) const DEFAULT_MAX_BINDING_REQUESTS: u16 = 7;
+
+/// The number of bytes that can be buffered before we start to error.
+pub(crate) const MAX_BUFFER_SIZE: usize = 1000 * 1000; // 1MB
+
+/// Wait time before binding requests can be deleted.
+pub(crate) const MAX_BINDING_REQUEST_TIMEOUT: Duration = Duration::from_millis(4000);
+
+pub(crate) fn default_candidate_types() -> Vec<CandidateType> {
+    vec![
+        CandidateType::Host,
+        CandidateType::ServerReflexive,
+        CandidateType::Relay,
+    ]
+}
+
+/// Collects the arguments to `ice::Agent` construction into a single structure, for
+/// future-proofness of the interface.
+#[derive(Default)]
+pub struct AgentConfig {
+    /// The STUN and TURN servers to gather reflexive and relay candidates from.
+    pub urls: Vec<Url>,
+
+    /// It is used to perform connectivity checks. The values MUST be unguessable, with at least
+    /// 128 bits of random number generator output used to generate the password, and at least 24
+    /// bits of output to generate the username fragment.
+    pub local_ufrag: String,
+    /// It is used to perform connectivity checks. The values MUST be unguessable, with at least
+    /// 128 bits of random number generator output used to generate the password, and at least 24
+    /// bits of output to generate the username fragment.
+    pub local_pwd: String,
+
+    /// Controls mDNS query timeout
+    /// If the duration is 0, we will never go to failed.
+    pub multicast_dns_query_timeout: Option<Duration>,
+
+    /// Controls mDNS behavior for the ICE agent.
+    pub multicast_dns_mode: MulticastDnsMode,
+
+    /// Controls the local name for this agent. If none is specified a random one will be generated.
+    pub multicast_dns_local_name: String,
+
+    /// Control mDNS local IP address
+    pub multicast_dns_local_ip: Option<IpAddr>,
+
+    /// Defaults to 5 seconds when this property is nil.
+    /// If the duration is 0, the ICE Agent will never go to disconnected.
+    pub disconnected_timeout: Option<Duration>,
+
+    /// Defaults to 25 seconds when this property is nil.
+    /// If the duration is 0, we will never go to failed.
+    pub failed_timeout: Option<Duration>,
+
+    /// Determines how often should we send ICE keepalives (should be less than connection timeout
+    /// above) when this is nil, it defaults to 10 seconds.
+    /// A keepalive interval of 0 means we never send keepalive packets
+    pub keepalive_interval: Option<Duration>,
+
+    /// An optional configuration for disabling or enabling support for specific candidate types.
+    pub candidate_types: Vec<CandidateType>,
+
+    /// An optional configuration for disabling or enabling support for specific network types.
+    /// If empty, all network types are supported.
+    pub network_types: Vec<NetworkType>,
+
+    /// Controls how often our internal task loop runs when in the connecting state.
+    /// Only useful for testing.
+    pub check_interval: Duration,
+
+    /// The max amount of binding requests the agent will send over a candidate pair for validation
+    /// or nomination, if after max_binding_requests the candidate is yet to answer a binding
+    /// request or a nomination we set the pair as failed.
+    pub max_binding_requests: Option<u16>,
+
+    /// Whether this agent takes the controlling role.
+    pub is_controlling: bool,
+
+    /// lite agents do not perform connectivity check and only provide host candidates.
+    pub lite: bool,
+
+    /// Specify a minimum wait time before selecting host candidates.
+    pub host_acceptance_min_wait: Option<Duration>,
+    /// Specify a minimum wait time before selecting srflx candidates.
+    pub srflx_acceptance_min_wait: Option<Duration>,
+    /// Specify a minimum wait time before selecting prflx candidates.
+    pub prflx_acceptance_min_wait: Option<Duration>,
+    /// Specify a minimum wait time before selecting relay candidates.
+    pub relay_acceptance_min_wait: Option<Duration>,
+
+    /// Controls if self-signed certificates are accepted when connecting to TURN servers via TLS or
+    /// DTLS.
+    pub insecure_skip_verify: bool,
+}

package/engine/vendor/rtc-ice/src/agent/agent_proto.rs

@@ -0,0 +1,172 @@
+use super::*;
+use mdns::{MDNS_PORT, MdnsEvent};
+
+impl sansio::Protocol<TaggedBytesMut, (), ()> for Agent {
+    type Rout = TaggedBytesMut;
+    type Wout = TaggedBytesMut;
+    type Eout = TaggedEvent;
+    type Error = Error;
+    type Time = Instant;
+
+    fn handle_read(&mut self, msg: TaggedBytesMut) -> Result<()> {
+        // demuxing mDNS packet from STUN packet whether peer addr port is MDNS_PORT
+        if msg.transport.peer_addr.port() == MDNS_PORT {
+            let remote_candidates = if let Some(mdns_conn) = &mut self.mdns {
+                mdns_conn.handle_read(msg)?;
+
+                let mut remote_candidates = vec![];
+                // After mdns handle_read, check any query result
+                while let Some(event) = mdns_conn.poll_event() {
+                    match event {
+                        MdnsEvent::QueryAnswered(id, addr) => {
+                            if let Some(mut c) = self.mdns_queries.remove(&id)
+                                && c.set_ip(&addr).is_ok()
+                            {
+                                debug!(
+                                    "mDNS query id {} answered Candidate {} with resolved_addr {} is added into remote candidates",
+                                    id,
+                                    c,
+                                    c.addr()
+                                );
+                                remote_candidates.push(c);
+                            }
+                        }
+                        MdnsEvent::QueryTimeout(id) => {
+                            if let Some(c) = self.mdns_queries.remove(&id) {
+                                error!("mDNS Query {} timed out for {}", id, c.address());
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+                remote_candidates
+            } else {
+                vec![]
+            };
+
+            self.trigger_request_connectivity_check(remote_candidates);
+
+            Ok(())
+        } else if let Some(local_index) =
+            self.find_local_candidate(msg.transport.local_addr, msg.transport.transport_protocol)
+        {
+            self.handle_inbound_candidate_msg(local_index, msg)
+        } else {
+            warn!(
+                "[{}]: Discarded message, not a valid local candidate from {:?}:{}",
+                self.get_name(),
+                msg.transport.transport_protocol,
+                msg.transport.local_addr,
+            );
+            Err(Error::ErrUnhandledStunpacket)
+        }
+    }
+
+    fn poll_read(&mut self) -> Option<Self::Rout> {
+        None
+    }
+
+    fn handle_write(&mut self, _msg: ()) -> std::result::Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn poll_write(&mut self) -> Option<Self::Wout> {
+        if let Some(mdns_conn) = &mut self.mdns {
+            while let Some(msg) = mdns_conn.poll_write() {
+                self.write_outs.push_back(msg);
+            }
+        }
+
+        self.write_outs.pop_front()
+    }
+
+    fn handle_event(&mut self, _evt: ()) -> std::result::Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn poll_event(&mut self) -> Option<Self::Eout> {
+        self.event_outs.pop_front()
+    }
+
+    fn handle_timeout(&mut self, now: Self::Time) -> std::result::Result<(), Self::Error> {
+        let remote_candidates = if let Some(mdns_conn) = &mut self.mdns {
+            let _ = mdns_conn.handle_timeout(now);
+
+            let mut remote_candidates = vec![];
+            // After mdns handle_timeout, check any query result
+            while let Some(event) = mdns_conn.poll_event() {
+                match event {
+                    MdnsEvent::QueryAnswered(id, addr) => {
+                        if let Some(mut c) = self.mdns_queries.remove(&id)
+                            && c.set_ip(&addr).is_ok()
+                        {
+                            debug!(
+                                "mDNS query id {} answered Candidate {} with resolved_addr {} is added into remote candidates",
+                                id,
+                                c,
+                                c.addr()
+                            );
+                            remote_candidates.push(c);
+                        }
+                    }
+                    MdnsEvent::QueryTimeout(id) => {
+                        if let Some(c) = self.mdns_queries.remove(&id) {
+                            error!("mDNS Query {} timed out for {}", id, c.address());
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            remote_candidates
+        } else {
+            vec![]
+        };
+        self.trigger_request_connectivity_check(remote_candidates);
+
+        if self.ufrag_pwd.remote_credentials.is_some()
+            && (self.force_candidate_contact
+                || self.last_checking_time + self.get_timeout_interval() <= now)
+        {
+            self.contact(now);
+        }
+        Ok(())
+    }
+
+    fn poll_timeout(&mut self) -> Option<Self::Time> {
+        let mdns_timeout = if let Some(mdns_conn) = &mut self.mdns {
+            mdns_conn.poll_timeout()
+        } else {
+            None
+        };
+
+        let ice_timeout = if self.ufrag_pwd.remote_credentials.is_some()
+            && !matches!(
+                self.connection_state,
+                ConnectionState::Failed | ConnectionState::Closed
+            ) {
+            if self.force_candidate_contact {
+                // A connectivity check was requested; ask the driver to call
+                // `handle_timeout` as soon as possible. `last_checking_time` is in the
+                // past, so the resulting deadline is immediate.
+                Some(self.last_checking_time)
+            } else {
+                Some(self.last_checking_time + self.get_timeout_interval())
+            }
+        } else {
+            None
+        };
+
+        // This treats the two options as a collection and picks the minimum
+        [mdns_timeout, ice_timeout].into_iter().flatten().min()
+    }
+
+    fn close(&mut self) -> std::result::Result<(), Self::Error> {
+        self.set_selected_pair(None, None);
+        self.delete_all_candidates(false);
+        self.update_connection_state(None, ConnectionState::Closed);
+        if let Some(mdns_conn) = &mut self.mdns {
+            mdns_conn.close()?;
+        }
+        Ok(())
+    }
+}