@desklink/host 0.5.3 → 0.5.6

package/engine/vendor/rtc-ice/src/attributes/control/control_test.rs

@@ -0,0 +1,168 @@
+use super::*;
+use shared::error::{Error, Result};
+
+#[test]
+fn test_controlled_get_from() -> Result<()> {
+    let mut m = Message::new();
+    let mut c = AttrControlled(4321);
+    let result = c.get_from(&m);
+    if let Err(err) = result {
+        assert_eq!(Error::ErrAttributeNotFound, err, "unexpected error");
+    } else {
+        panic!("expected error, but got ok");
+    }
+
+    m.build(&[Box::new(BINDING_REQUEST), Box::new(c)])?;
+
+    let mut m1 = Message::new();
+    m1.write(&m.raw)?;
+
+    let mut c1 = AttrControlled::default();
+    c1.get_from(&m1)?;
+
+    assert_eq!(c1, c, "not equal");
+
+    //"IncorrectSize"
+    {
+        let mut m3 = Message::new();
+        m3.add(ATTR_ICE_CONTROLLED, &[0; 100]);
+        let mut c2 = AttrControlled::default();
+        let result = c2.get_from(&m3);
+        if let Err(err) = result {
+            assert!(is_attr_size_invalid(&err), "should error");
+        } else {
+            panic!("expected error, but got ok");
+        }
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_controlling_get_from() -> Result<()> {
+    let mut m = Message::new();
+    let mut c = AttrControlling(4321);
+    let result = c.get_from(&m);
+    if let Err(err) = result {
+        assert_eq!(Error::ErrAttributeNotFound, err, "unexpected error");
+    } else {
+        panic!("expected error, but got ok");
+    }
+
+    m.build(&[Box::new(BINDING_REQUEST), Box::new(c)])?;
+
+    let mut m1 = Message::new();
+    m1.write(&m.raw)?;
+
+    let mut c1 = AttrControlling::default();
+    c1.get_from(&m1)?;
+
+    assert_eq!(c1, c, "not equal");
+
+    //"IncorrectSize"
+    {
+        let mut m3 = Message::new();
+        m3.add(ATTR_ICE_CONTROLLING, &[0; 100]);
+        let mut c2 = AttrControlling::default();
+        let result = c2.get_from(&m3);
+        if let Err(err) = result {
+            assert!(is_attr_size_invalid(&err), "should error");
+        } else {
+            panic!("expected error, but got ok");
+        }
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_control_get_from() -> Result<()> {
+    //"Blank"
+    {
+        let m = Message::new();
+        let mut c = AttrControl::default();
+        let result = c.get_from(&m);
+        if let Err(err) = result {
+            assert_eq!(Error::ErrAttributeNotFound, err, "unexpected error");
+        } else {
+            panic!("expected error, but got ok");
+        }
+    }
+    //"Controlling"
+    {
+        let mut m = Message::new();
+        let mut c = AttrControl::default();
+        let result = c.get_from(&m);
+        if let Err(err) = result {
+            assert_eq!(Error::ErrAttributeNotFound, err, "unexpected error");
+        } else {
+            panic!("expected error, but got ok");
+        }
+
+        c.role = Role::Controlling;
+        c.tie_breaker = TieBreaker(4321);
+
+        m.build(&[Box::new(BINDING_REQUEST), Box::new(c)])?;
+
+        let mut m1 = Message::new();
+        m1.write(&m.raw)?;
+
+        let mut c1 = AttrControl::default();
+        c1.get_from(&m1)?;
+
+        assert_eq!(c1, c, "not equal");
+
+        //"IncorrectSize"
+        {
+            let mut m3 = Message::new();
+            m3.add(ATTR_ICE_CONTROLLING, &[0; 100]);
+            let mut c2 = AttrControl::default();
+            let result = c2.get_from(&m3);
+            if let Err(err) = result {
+                assert!(is_attr_size_invalid(&err), "should error");
+            } else {
+                panic!("expected error, but got ok");
+            }
+        }
+    }
+
+    //"Controlled"
+    {
+        let mut m = Message::new();
+        let mut c = AttrControl::default();
+        let result = c.get_from(&m);
+        if let Err(err) = result {
+            assert_eq!(Error::ErrAttributeNotFound, err, "unexpected error");
+        } else {
+            panic!("expected error, but got ok");
+        }
+
+        c.role = Role::Controlled;
+        c.tie_breaker = TieBreaker(1234);
+
+        m.build(&[Box::new(BINDING_REQUEST), Box::new(c)])?;
+
+        let mut m1 = Message::new();
+        m1.write(&m.raw)?;
+
+        let mut c1 = AttrControl::default();
+        c1.get_from(&m1)?;
+
+        assert_eq!(c1, c, "not equal");
+
+        //"IncorrectSize"
+        {
+            let mut m3 = Message::new();
+            m3.add(ATTR_ICE_CONTROLLING, &[0; 100]);
+            let mut c2 = AttrControl::default();
+            let result = c2.get_from(&m3);
+            if let Err(err) = result {
+                assert!(is_attr_size_invalid(&err), "should error");
+            } else {
+                panic!("expected error, but got ok");
+            }
+        }
+    }
+
+    Ok(())
+}

package/engine/vendor/rtc-ice/src/attributes/control/mod.rs

@@ -0,0 +1,142 @@
+#[cfg(test)]
+mod control_test;
+
+use std::fmt;
+
+use shared::error::*;
+use stun::attributes::*;
+use stun::checks::*;
+use stun::message::*;
+
+/// Common helper for ICE-{CONTROLLED,CONTROLLING} and represents the so-called Tiebreaker number.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+pub struct TieBreaker(pub u64);
+
+pub(crate) const TIE_BREAKER_SIZE: usize = 8; // 64 bit
+
+impl TieBreaker {
+    /// Adds Tiebreaker value to m as t attribute.
+    pub fn add_to_as(self, m: &mut Message, t: AttrType) -> Result<()> {
+        let mut v = vec![0; TIE_BREAKER_SIZE];
+        v.copy_from_slice(&self.0.to_be_bytes());
+        m.add(t, &v);
+        Ok(())
+    }
+
+    /// Decodes Tiebreaker value in message getting it as for t type.
+    pub fn get_from_as(&mut self, m: &Message, t: AttrType) -> Result<()> {
+        let v = m.get(t)?;
+        check_size(t, v.len(), TIE_BREAKER_SIZE)?;
+        self.0 = u64::from_be_bytes([v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]]);
+        Ok(())
+    }
+}
+/// Represents ICE-CONTROLLED attribute.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+pub struct AttrControlled(pub u64);
+
+impl Setter for AttrControlled {
+    /// Adds ICE-CONTROLLED to message.
+    fn add_to(&self, m: &mut Message) -> Result<()> {
+        TieBreaker(self.0).add_to_as(m, ATTR_ICE_CONTROLLED)
+    }
+}
+
+impl Getter for AttrControlled {
+    /// Decodes ICE-CONTROLLED from message.
+    fn get_from(&mut self, m: &Message) -> Result<()> {
+        let mut t = TieBreaker::default();
+        t.get_from_as(m, ATTR_ICE_CONTROLLED)?;
+        self.0 = t.0;
+        Ok(())
+    }
+}
+
+/// Represents ICE-CONTROLLING attribute.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+pub struct AttrControlling(pub u64);
+
+impl Setter for AttrControlling {
+    // add_to adds ICE-CONTROLLING to message.
+    fn add_to(&self, m: &mut Message) -> Result<()> {
+        TieBreaker(self.0).add_to_as(m, ATTR_ICE_CONTROLLING)
+    }
+}
+
+impl Getter for AttrControlling {
+    // get_from decodes ICE-CONTROLLING from message.
+    fn get_from(&mut self, m: &Message) -> Result<()> {
+        let mut t = TieBreaker::default();
+        t.get_from_as(m, ATTR_ICE_CONTROLLING)?;
+        self.0 = t.0;
+        Ok(())
+    }
+}
+
+/// Helper that wraps ICE-{CONTROLLED,CONTROLLING}.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+pub struct AttrControl {
+    role: Role,
+    tie_breaker: TieBreaker,
+}
+
+impl Setter for AttrControl {
+    // add_to adds ICE-CONTROLLED or ICE-CONTROLLING attribute depending on Role.
+    fn add_to(&self, m: &mut Message) -> Result<()> {
+        if self.role == Role::Controlling {
+            self.tie_breaker.add_to_as(m, ATTR_ICE_CONTROLLING)
+        } else {
+            self.tie_breaker.add_to_as(m, ATTR_ICE_CONTROLLED)
+        }
+    }
+}
+
+impl Getter for AttrControl {
+    // get_from decodes Role and Tiebreaker value from message.
+    fn get_from(&mut self, m: &Message) -> Result<()> {
+        if m.contains(ATTR_ICE_CONTROLLING) {
+            self.role = Role::Controlling;
+            return self.tie_breaker.get_from_as(m, ATTR_ICE_CONTROLLING);
+        }
+        if m.contains(ATTR_ICE_CONTROLLED) {
+            self.role = Role::Controlled;
+            return self.tie_breaker.get_from_as(m, ATTR_ICE_CONTROLLED);
+        }
+
+        Err(Error::ErrAttributeNotFound)
+    }
+}
+
+/// Represents ICE agent role, which can be controlling or controlled.
+/// Possible ICE agent roles.
+#[derive(Default, PartialEq, Eq, Copy, Clone, Debug)]
+pub enum Role {
+    #[default]
+    /// This agent is controlling.
+    Controlling,
+    /// This agent is controlled.
+    Controlled,
+    /// No role attribute was present.
+    Unspecified,
+}
+
+impl From<&str> for Role {
+    fn from(raw: &str) -> Self {
+        match raw {
+            "controlling" => Self::Controlling,
+            "controlled" => Self::Controlled,
+            _ => Self::Unspecified,
+        }
+    }
+}
+
+impl fmt::Display for Role {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            Self::Controlling => "controlling",
+            Self::Controlled => "controlled",
+            Self::Unspecified => "unspecified",
+        };
+        write!(f, "{s}")
+    }
+}

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

@@ -0,0 +1,6 @@
+/// `ICE-CONTROLLING` and `ICE-CONTROLLED`, which resolve role conflicts.
+pub mod control;
+/// The `PRIORITY` attribute carried in connectivity checks.
+pub mod priority;
+/// The `USE-CANDIDATE` flag, by which the controlling agent nominates a pair.
+pub mod use_candidate;

package/engine/vendor/rtc-ice/src/attributes/priority/mod.rs

@@ -0,0 +1,37 @@
+#[cfg(test)]
+mod priority_test;
+
+use shared::error::*;
+use stun::attributes::ATTR_PRIORITY;
+use stun::checks::*;
+use stun::message::*;
+
+/// Represents PRIORITY attribute.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+pub struct PriorityAttr(pub u32);
+
+const PRIORITY_SIZE: usize = 4; // 32 bit
+
+impl Setter for PriorityAttr {
+    // add_to adds PRIORITY attribute to message.
+    fn add_to(&self, m: &mut Message) -> Result<()> {
+        let mut v = vec![0_u8; PRIORITY_SIZE];
+        v.copy_from_slice(&self.0.to_be_bytes());
+        m.add(ATTR_PRIORITY, &v);
+        Ok(())
+    }
+}
+
+impl PriorityAttr {
+    /// Decodes PRIORITY attribute from message.
+    pub fn get_from(&mut self, m: &Message) -> Result<()> {
+        let v = m.get(ATTR_PRIORITY)?;
+
+        check_size(ATTR_PRIORITY, v.len(), PRIORITY_SIZE)?;
+
+        let p = u32::from_be_bytes([v[0], v[1], v[2], v[3]]);
+        self.0 = p;
+
+        Ok(())
+    }
+}

package/engine/vendor/rtc-ice/src/attributes/priority/priority_test.rs

@@ -0,0 +1,39 @@
+use super::*;
+use shared::error::{Error, Result};
+
+#[test]
+fn test_priority_get_from() -> Result<()> {
+    let mut m = Message::new();
+    let mut p = PriorityAttr::default();
+    let result = p.get_from(&m);
+    if let Err(err) = result {
+        assert_eq!(err, Error::ErrAttributeNotFound, "unexpected error");
+    } else {
+        panic!("expected error, but got ok");
+    }
+
+    m.build(&[Box::new(BINDING_REQUEST), Box::new(p)])?;
+
+    let mut m1 = Message::new();
+    m1.write(&m.raw)?;
+
+    let mut p1 = PriorityAttr::default();
+    p1.get_from(&m1)?;
+
+    assert_eq!(p1, p, "not equal");
+
+    //"IncorrectSize"
+    {
+        let mut m3 = Message::new();
+        m3.add(ATTR_PRIORITY, &[0; 100]);
+        let mut p2 = PriorityAttr::default();
+        let result = p2.get_from(&m3);
+        if let Err(err) = result {
+            assert!(is_attr_size_invalid(&err), "should error");
+        } else {
+            panic!("expected error, but got ok");
+        }
+    }
+
+    Ok(())
+}

package/engine/vendor/rtc-ice/src/attributes/use_candidate/mod.rs

@@ -0,0 +1,33 @@
+#[cfg(test)]
+mod use_candidate_test;
+
+use shared::error::*;
+use stun::attributes::ATTR_USE_CANDIDATE;
+use stun::message::*;
+
+/// Represents USE-CANDIDATE attribute.
+#[derive(Default)]
+pub struct UseCandidateAttr;
+
+impl Setter for UseCandidateAttr {
+    /// Adds USE-CANDIDATE attribute to message.
+    fn add_to(&self, m: &mut Message) -> Result<()> {
+        m.add(ATTR_USE_CANDIDATE, &[]);
+        Ok(())
+    }
+}
+
+impl UseCandidateAttr {
+    #[must_use]
+    /// A `USE-CANDIDATE` attribute, which carries no value.
+    pub const fn new() -> Self {
+        Self
+    }
+
+    /// Returns true if USE-CANDIDATE attribute is set.
+    #[must_use]
+    pub fn is_set(m: &Message) -> bool {
+        let result = m.get(ATTR_USE_CANDIDATE);
+        result.is_ok()
+    }
+}

package/engine/vendor/rtc-ice/src/attributes/use_candidate/use_candidate_test.rs

@@ -0,0 +1,19 @@
+use stun::message::BINDING_REQUEST;
+
+use super::*;
+use shared::error::Result;
+
+#[test]
+fn test_use_candidate_attr_add_to() -> Result<()> {
+    let mut m = Message::new();
+    assert!(!UseCandidateAttr::is_set(&m), "should not be set");
+
+    m.build(&[Box::new(BINDING_REQUEST), Box::new(UseCandidateAttr::new())])?;
+
+    let mut m1 = Message::new();
+    m1.write(&m.raw)?;
+
+    assert!(UseCandidateAttr::is_set(&m1), "should be set");
+
+    Ok(())
+}

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

@@ -0,0 +1,53 @@
+use super::*;
+use crate::rand::generate_cand_id;
+
+/// The config required to create a new `CandidateHost`.
+#[derive(Default)]
+pub struct CandidateHostConfig {
+    /// The fields shared by every candidate type.
+    pub base_config: CandidateConfig,
+
+    /// The TCP role, for ICE-TCP host candidates.
+    pub tcp_type: TcpType,
+}
+
+impl CandidateHostConfig {
+    /// Creates a new host candidate.
+    pub fn new_candidate_host(self) -> Result<Candidate> {
+        let mut candidate_id = self.base_config.candidate_id;
+        if candidate_id.is_empty() {
+            candidate_id = generate_cand_id();
+        }
+
+        let (resolved_addr, network_type) = if !self.base_config.address.ends_with(".local") {
+            let ip: IpAddr = match self.base_config.address.parse() {
+                Ok(ip) => ip,
+                Err(_) => return Err(Error::ErrAddressParseFailed),
+            };
+            (
+                SocketAddr::new(ip, self.base_config.port),
+                determine_network_type(&self.base_config.network, &ip)?,
+            )
+        } else {
+            (
+                SocketAddr::new(IpAddr::from([0, 0, 0, 0]), 0),
+                NetworkType::Udp4,
+            )
+        };
+
+        Ok(Candidate {
+            id: candidate_id,
+            network_type,
+            candidate_type: CandidateType::Host,
+            address: self.base_config.address,
+            port: self.base_config.port,
+            resolved_addr,
+            component: self.base_config.component,
+            foundation_override: self.base_config.foundation,
+            priority_override: self.base_config.priority,
+            network: self.base_config.network,
+            tcp_type: self.tcp_type,
+            ..Candidate::default()
+        })
+    }
+}