@desklink/host 0.5.3 → 0.5.4

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

@@ -0,0 +1,266 @@
+#[cfg(test)]
+mod url_test;
+
+use std::borrow::Cow;
+use std::convert::From;
+use std::fmt;
+
+use shared::error::*;
+
+/// The type of server used in the ice.URL structure.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+#[non_exhaustive]
+pub enum SchemeType {
+    /// The URL represents a STUN server.
+    Stun,
+
+    /// The URL represents a STUNS (secure) server.
+    Stuns,
+
+    /// The URL represents a TURN server.
+    Turn,
+
+    /// The URL represents a TURNS (secure) server.
+    Turns,
+
+    #[default]
+    /// Default public constant to use for "enum" like struct comparisons when no value was defined.
+    /// A scheme or transport this crate does not recognise.
+    Unknown,
+}
+
+impl From<&str> for SchemeType {
+    /// Defines a procedure for creating a new `SchemeType` from a raw
+    /// string naming the scheme type.
+    fn from(raw: &str) -> Self {
+        match raw {
+            "stun" => Self::Stun,
+            "stuns" => Self::Stuns,
+            "turn" => Self::Turn,
+            "turns" => Self::Turns,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl fmt::Display for SchemeType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            SchemeType::Stun => "stun",
+            SchemeType::Stuns => "stuns",
+            SchemeType::Turn => "turn",
+            SchemeType::Turns => "turns",
+            SchemeType::Unknown => "unknown",
+        };
+        write!(f, "{s}")
+    }
+}
+
+/// The transport protocol type that is used in the `ice::url::Url` structure.
+#[derive(Default, PartialEq, Eq, Debug, Copy, Clone)]
+#[non_exhaustive]
+pub enum ProtoType {
+    /// The URL uses a UDP transport.
+    #[default]
+    Udp,
+
+    /// The URL uses a TCP transport.
+    Tcp,
+
+    /// A transport this crate does not recognise.
+    Unknown,
+}
+
+// defines a procedure for creating a new ProtoType from a raw
+// string naming the transport protocol type.
+impl From<&str> for ProtoType {
+    // NewSchemeType defines a procedure for creating a new SchemeType from a raw
+    // string naming the scheme type.
+    fn from(raw: &str) -> Self {
+        match raw {
+            "udp" => Self::Udp,
+            "tcp" => Self::Tcp,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl fmt::Display for ProtoType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = match *self {
+            Self::Udp => "udp",
+            Self::Tcp => "tcp",
+            Self::Unknown => "unknown",
+        };
+        write!(f, "{s}")
+    }
+}
+
+/// Represents a STUN (rfc7064) or TURN (rfc7065) URL.
+#[derive(Debug, Clone, Default)]
+pub struct Url {
+    /// The URL scheme: `stun`, `stuns`, `turn` or `turns`.
+    pub scheme: SchemeType,
+    /// The server host name or address.
+    pub host: String,
+    /// The server port; defaults to 3478, or 5349 for the secure schemes.
+    pub port: u16,
+    /// The TURN username, for `turn:`/`turns:` URLs.
+    pub username: String,
+    /// The TURN credential.
+    pub password: String,
+    /// The transport to reach the server over, from the URL's `?transport=` parameter.
+    pub proto: ProtoType,
+}
+
+impl fmt::Display for Url {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let host = if self.host.contains("::") {
+            "[".to_owned() + self.host.as_str() + "]"
+        } else {
+            self.host.clone()
+        };
+        if self.scheme == SchemeType::Turn || self.scheme == SchemeType::Turns {
+            write!(
+                f,
+                "{}:{}:{}?transport={}",
+                self.scheme, host, self.port, self.proto
+            )
+        } else {
+            write!(f, "{}:{}:{}", self.scheme, host, self.port)
+        }
+    }
+}
+
+impl Url {
+    /// Parses a STUN or TURN urls following the ABNF syntax described in
+    /// [IETF rfc-7064](https://tools.ietf.org/html/rfc7064) and
+    /// [IETF rfc-7065](https://tools.ietf.org/html/rfc7065) respectively.
+    pub fn parse_url(raw: &str) -> Result<Self> {
+        // work around for url crate
+        if raw.contains("//") {
+            return Err(Error::ErrInvalidUrl);
+        }
+
+        let mut s = raw.to_string();
+        let pos = raw.find(':');
+        if let Some(p) = pos {
+            s.replace_range(p..=p, "://");
+        } else {
+            return Err(Error::ErrSchemeType);
+        }
+
+        let raw_parts = url::Url::parse(&s)?;
+
+        let scheme = raw_parts.scheme().into();
+
+        let host = if let Some(host) = raw_parts.host_str() {
+            host.trim()
+                .trim_start_matches('[')
+                .trim_end_matches(']')
+                .to_owned()
+        } else {
+            return Err(Error::ErrHost);
+        };
+
+        let port = if let Some(port) = raw_parts.port() {
+            port
+        } else if scheme == SchemeType::Stun || scheme == SchemeType::Turn {
+            3478
+        } else {
+            5349
+        };
+
+        let mut q_args = raw_parts.query_pairs();
+        let proto = match scheme {
+            SchemeType::Stun => {
+                if q_args.count() > 0 {
+                    return Err(Error::ErrStunQuery);
+                }
+                ProtoType::Udp
+            }
+            SchemeType::Stuns => {
+                if q_args.count() > 0 {
+                    return Err(Error::ErrStunQuery);
+                }
+                ProtoType::Tcp
+            }
+            SchemeType::Turn => {
+                if q_args.count() > 1 {
+                    return Err(Error::ErrInvalidQuery);
+                }
+                if let Some((key, value)) = q_args.next() {
+                    if key == Cow::Borrowed("transport") {
+                        let proto: ProtoType = value.as_ref().into();
+                        if proto == ProtoType::Unknown {
+                            return Err(Error::ErrProtoType);
+                        }
+                        proto
+                    } else {
+                        return Err(Error::ErrInvalidQuery);
+                    }
+                } else {
+                    ProtoType::Udp
+                }
+            }
+            SchemeType::Turns => {
+                if q_args.count() > 1 {
+                    return Err(Error::ErrInvalidQuery);
+                }
+                if let Some((key, value)) = q_args.next() {
+                    if key == Cow::Borrowed("transport") {
+                        let proto: ProtoType = value.as_ref().into();
+                        if proto == ProtoType::Unknown {
+                            return Err(Error::ErrProtoType);
+                        }
+                        proto
+                    } else {
+                        return Err(Error::ErrInvalidQuery);
+                    }
+                } else {
+                    ProtoType::Tcp
+                }
+            }
+            SchemeType::Unknown => {
+                return Err(Error::ErrSchemeType);
+            }
+        };
+
+        Ok(Self {
+            scheme,
+            host,
+            port,
+            username: "".to_owned(),
+            password: "".to_owned(),
+            proto,
+        })
+    }
+
+    /*
+    fn parse_proto(raw:&str) ->Result<ProtoType> {
+        let qArgs= raw.split('=');
+        if qArgs.len() != 2 {
+            return Err(Error::ErrInvalidQuery.into());
+        }
+
+        var proto ProtoType
+        if rawProto := qArgs.Get("transport"); rawProto != "" {
+            if proto = NewProtoType(rawProto); proto == ProtoType(0) {
+                return ProtoType(Unknown), ErrProtoType
+            }
+            return proto, nil
+        }
+
+        if len(qArgs) > 0 {
+            return ProtoType(Unknown), ErrInvalidQuery
+        }
+
+        return proto, nil
+    }*/
+
+    /// Returns whether the this URL's scheme describes secure scheme or not.
+    #[must_use]
+    pub fn is_secure(&self) -> bool {
+        self.scheme == SchemeType::Stuns || self.scheme == SchemeType::Turns
+    }
+}

package/engine/vendor/rtc-ice/src/url/url_test.rs

@@ -0,0 +1,142 @@
+use super::*;
+
+#[test]
+fn test_parse_url_success() -> Result<()> {
+    let tests = vec![
+        (
+            "stun:google.de",
+            "stun:google.de:3478",
+            SchemeType::Stun,
+            false,
+            "google.de",
+            3478,
+            ProtoType::Udp,
+        ),
+        (
+            "stun:google.de:1234",
+            "stun:google.de:1234",
+            SchemeType::Stun,
+            false,
+            "google.de",
+            1234,
+            ProtoType::Udp,
+        ),
+        (
+            "stuns:google.de",
+            "stuns:google.de:5349",
+            SchemeType::Stuns,
+            true,
+            "google.de",
+            5349,
+            ProtoType::Tcp,
+        ),
+        (
+            "stun:[::1]:123",
+            "stun:[::1]:123",
+            SchemeType::Stun,
+            false,
+            "::1",
+            123,
+            ProtoType::Udp,
+        ),
+        (
+            "turn:google.de",
+            "turn:google.de:3478?transport=udp",
+            SchemeType::Turn,
+            false,
+            "google.de",
+            3478,
+            ProtoType::Udp,
+        ),
+        (
+            "turns:google.de",
+            "turns:google.de:5349?transport=tcp",
+            SchemeType::Turns,
+            true,
+            "google.de",
+            5349,
+            ProtoType::Tcp,
+        ),
+        (
+            "turn:google.de?transport=udp",
+            "turn:google.de:3478?transport=udp",
+            SchemeType::Turn,
+            false,
+            "google.de",
+            3478,
+            ProtoType::Udp,
+        ),
+        (
+            "turns:google.de?transport=tcp",
+            "turns:google.de:5349?transport=tcp",
+            SchemeType::Turns,
+            true,
+            "google.de",
+            5349,
+            ProtoType::Tcp,
+        ),
+    ];
+
+    for (
+        raw_url,
+        expected_url_string,
+        expected_scheme,
+        expected_secure,
+        expected_host,
+        expected_port,
+        expected_proto,
+    ) in tests
+    {
+        let url = Url::parse_url(raw_url)?;
+
+        assert_eq!(url.scheme, expected_scheme, "testCase: {raw_url:?}");
+        assert_eq!(
+            expected_url_string,
+            url.to_string(),
+            "testCase: {raw_url:?}"
+        );
+        assert_eq!(url.is_secure(), expected_secure, "testCase: {raw_url:?}");
+        assert_eq!(url.host, expected_host, "testCase: {raw_url:?}");
+        assert_eq!(url.port, expected_port, "testCase: {raw_url:?}");
+        assert_eq!(url.proto, expected_proto, "testCase: {raw_url:?}");
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_parse_url_failure() -> Result<()> {
+    let tests = vec![
+        ("", Error::ErrSchemeType),
+        (":::", Error::ErrUrlParse),
+        ("stun:[::1]:123:", Error::ErrPort),
+        ("stun:[::1]:123a", Error::ErrPort),
+        ("google.de", Error::ErrSchemeType),
+        ("stun:", Error::ErrHost),
+        ("stun:google.de:abc", Error::ErrPort),
+        ("stun:google.de?transport=udp", Error::ErrStunQuery),
+        ("stuns:google.de?transport=udp", Error::ErrStunQuery),
+        ("turn:google.de?trans=udp", Error::ErrInvalidQuery),
+        ("turns:google.de?trans=udp", Error::ErrInvalidQuery),
+        (
+            "turns:google.de?transport=udp&another=1",
+            Error::ErrInvalidQuery,
+        ),
+        ("turn:google.de?transport=ip", Error::ErrProtoType),
+    ];
+
+    for (raw_url, expected_err) in tests {
+        let result = Url::parse_url(raw_url);
+        if let Err(err) = result {
+            assert_eq!(
+                err.to_string(),
+                expected_err.to_string(),
+                "testCase: '{raw_url}', expected err '{expected_err}', but got err '{err}'"
+            );
+        } else {
+            panic!("expected error, but got ok");
+        }
+    }
+
+    Ok(())
+}

package/package.json

@@ -1,7 +1,12 @@
 {
     "name": "@desklink/host",
-    "version": "0.5.3",
+    "version": "0.5.4",
     "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/umeranjum17/desklink.git",
+        "directory": "packages/desktop-host"
+    },
     "description": "Per-user, on-demand desktop capture, encode and input engine with a versioned local control protocol",
     "type": "module",
     "main": "./dist/index.js",
@@ -33,7 +38,7 @@
         "ws": "8.21.3"
     },
     "optionalDependencies": {
-        "@desklink/host-linux-x64-gnu": "0.5.3",
-        "@desklink/host-darwin-arm64": "0.5.3"
+        "@desklink/host-linux-x64-gnu": "0.5.4",
+        "@desklink/host-darwin-arm64": "0.5.4"
     }
 }