@desklink/host 0.5.2 → 0.5.4

package/engine/vendor/rtc-ice/examples/ping_pong.rs

@@ -0,0 +1,376 @@
+use bytes::BytesMut;
+use clap::Parser;
+use futures::StreamExt;
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Body, Client, Method, Request, Response, Server, StatusCode};
+use rtc_ice::agent::Agent;
+use rtc_ice::agent::agent_config::AgentConfig;
+use rtc_ice::candidate::candidate_host::CandidateHostConfig;
+use rtc_ice::candidate::*;
+use rtc_ice::crypto;
+use rtc_ice::state::*;
+use rtc_ice::{Credentials, Event};
+use sansio::Protocol;
+use shared::error::Error;
+use shared::{TransportContext, TransportMessage, TransportProtocol};
+use std::io;
+use std::io::Write;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::net::UdpSocket;
+use tokio::sync::{Mutex, mpsc, watch};
+
+#[macro_use]
+extern crate lazy_static;
+
+type SenderType = Arc<Mutex<mpsc::Sender<String>>>;
+type ReceiverType = Arc<Mutex<mpsc::Receiver<String>>>;
+
+lazy_static! {
+    // ErrUnknownType indicates an error with Unknown info.
+    static ref REMOTE_AUTH_CHANNEL: (SenderType, ReceiverType ) = {
+        let (tx, rx) = mpsc::channel::<String>(3);
+        (Arc::new(Mutex::new(tx)), Arc::new(Mutex::new(rx)))
+    };
+
+    static ref REMOTE_CAND_CHANNEL: (SenderType, ReceiverType) = {
+        let (tx, rx) = mpsc::channel::<String>(10);
+        (Arc::new(Mutex::new(tx)), Arc::new(Mutex::new(rx)))
+    };
+}
+
+// HTTP Listener to get ICE Credentials/Candidate from remote Peer
+async fn remote_handler(req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
+    //println!("received {:?}", req);
+    match (req.method(), req.uri().path()) {
+        (&Method::POST, "/remoteAuth") => {
+            let full_body =
+                match std::str::from_utf8(&hyper::body::to_bytes(req.into_body()).await?) {
+                    Ok(s) => s.to_owned(),
+                    Err(err) => panic!("{}", err),
+                };
+            let tx = REMOTE_AUTH_CHANNEL.0.lock().await;
+            //println!("body: {:?}", full_body);
+            let _ = tx.send(full_body).await;
+
+            let mut response = Response::new(Body::empty());
+            *response.status_mut() = StatusCode::OK;
+            Ok(response)
+        }
+
+        (&Method::POST, "/remoteCandidate") => {
+            let full_body =
+                match std::str::from_utf8(&hyper::body::to_bytes(req.into_body()).await?) {
+                    Ok(s) => s.to_owned(),
+                    Err(err) => panic!("{}", err),
+                };
+            let tx = REMOTE_CAND_CHANNEL.0.lock().await;
+            //println!("body: {:?}", full_body);
+            let _ = tx.send(full_body).await;
+
+            let mut response = Response::new(Body::empty());
+            *response.status_mut() = StatusCode::OK;
+            Ok(response)
+        }
+
+        // Return the 404 Not Found for other routes.
+        _ => {
+            let mut not_found = Response::default();
+            *not_found.status_mut() = StatusCode::NOT_FOUND;
+            Ok(not_found)
+        }
+    }
+}
+
+// Controlled Agent:
+//      cargo run --color=always --package webrtc-ice --example ping_pong
+// Controlling Agent:
+//      cargo run --color=always --package webrtc-ice --example ping_pong -- --controlling
+
+#[derive(Parser)]
+#[command(name = "ICE Ping Pong")]
+#[command(author = "Rusty Rain <y@ngr.tc>")]
+#[command(version = "0.1.0")]
+#[command(about = "An example of ICE", long_about = None)]
+struct Cli {
+    #[arg(short, long)]
+    controlling: bool,
+
+    #[arg(short, long)]
+    debug: bool,
+    #[arg(long, default_value_t = format!("INFO"))]
+    log_level: String,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    let cli = Cli::parse();
+    if cli.debug {
+        let log_level = log::LevelFilter::from_str(&cli.log_level).unwrap();
+        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, log_level)
+            .init();
+    }
+
+    let (local_http_port, remote_http_port) = if cli.controlling {
+        (9000, 9001)
+    } else {
+        (9001, 9000)
+    };
+
+    let (done_tx, mut done_rx) = watch::channel(());
+
+    println!("Listening on http://localhost:{local_http_port}");
+    let mut done_http_server = done_rx.clone();
+    tokio::spawn(async move {
+        let addr = ([0, 0, 0, 0], local_http_port).into();
+        let service =
+            make_service_fn(|_| async { Ok::<_, hyper::Error>(service_fn(remote_handler)) });
+        let server = Server::bind(&addr).serve(service);
+        tokio::select! {
+            _ = done_http_server.changed() => {
+                println!("receive cancel http server!");
+            }
+            result = server => {
+                // Run this server for... forever!
+                if let Err(e) = result {
+                    eprintln!("server error: {e}");
+                }
+                println!("exit http server!");
+            }
+        };
+    });
+
+    if cli.controlling {
+        println!("Local Agent is controlling");
+    } else {
+        println!("Local Agent is controlled");
+    };
+    println!("Press 'Enter' when both processes have started");
+    let mut input = String::new();
+    let _ = io::stdin().read_line(&mut input)?;
+
+    let port = if cli.controlling { 4000 } else { 4001 };
+    let udp_socket = UdpSocket::bind(("0.0.0.0", port)).await?;
+    let mut ice_agent = Agent::new(
+        Instant::now(),
+        Arc::new(AgentConfig {
+            disconnected_timeout: Some(Duration::from_secs(5)),
+            failed_timeout: Some(Duration::from_secs(5)),
+            ..Default::default()
+        }),
+        crypto::default_provider().map_err(|e| Error::Other(e.to_string()))?,
+    )?;
+
+    let client = Arc::new(Client::new());
+
+    // When we have gathered a new ICE Candidate send it to the remote peer
+    let client2 = Arc::clone(&client);
+    let on_candidate = |c: Candidate| {
+        let client3 = Arc::clone(&client2);
+        Box::pin(async move {
+            println!("posting remoteCandidate with {}", c.marshal());
+
+            let req = match Request::builder()
+                .method(Method::POST)
+                .uri(format!(
+                    "http://localhost:{remote_http_port}/remoteCandidate"
+                ))
+                .body(Body::from(c.marshal()))
+            {
+                Ok(req) => req,
+                Err(err) => {
+                    println!("{err}");
+                    return;
+                }
+            };
+            let resp = match client3.request(req).await {
+                Ok(resp) => resp,
+                Err(err) => {
+                    println!("{err}");
+                    return;
+                }
+            };
+            println!("Response from remoteCandidate: {}", resp.status());
+        })
+    };
+
+    // Get the local auth details and send to remote peer
+    let Credentials {
+        ufrag: local_ufrag,
+        pwd: local_pwd,
+    } = ice_agent.get_local_credentials();
+
+    println!("posting remoteAuth with {local_ufrag}:{local_pwd}");
+    let req = match Request::builder()
+        .method(Method::POST)
+        .uri(format!("http://localhost:{remote_http_port}/remoteAuth"))
+        .body(Body::from(format!("{local_ufrag}:{local_pwd}")))
+    {
+        Ok(req) => req,
+        Err(err) => return Err(Error::Other(format!("{err}"))),
+    };
+    let resp = match client.request(req).await {
+        Ok(resp) => resp,
+        Err(err) => return Err(Error::Other(format!("{err}"))),
+    };
+    println!("Response from remoteAuth: {}", resp.status());
+
+    let (remote_ufrag, remote_pwd) = {
+        let mut rx = REMOTE_AUTH_CHANNEL.1.lock().await;
+        if let Some(s) = rx.recv().await {
+            println!("received: {s}");
+            let fields: Vec<String> = s.split(':').map(|s| s.to_string()).collect();
+            (fields[0].clone(), fields[1].clone())
+        } else {
+            panic!("rx.recv() empty");
+        }
+    };
+    println!("remote_ufrag: {remote_ufrag}, remote_pwd: {remote_pwd}");
+
+    // gather_candidates
+    println!("gathering candidates...");
+    let local_candidate = CandidateHostConfig {
+        base_config: CandidateConfig {
+            network: "udp".to_owned(),
+            address: udp_socket.local_addr()?.ip().to_string(),
+            port: udp_socket.local_addr()?.port(),
+            component: 1,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+    .new_candidate_host()?;
+    on_candidate(local_candidate.clone()).await;
+    ice_agent.add_local_candidate(local_candidate)?;
+
+    let remote_candidate = {
+        let mut rx = REMOTE_CAND_CHANNEL.1.lock().await;
+        if let Some(s) = rx.recv().await {
+            println!("received remote_candidate: {s}");
+            unmarshal_candidate(&s)?
+        } else {
+            panic!("rx.recv() empty");
+        }
+    };
+    let peer_addr = remote_candidate.addr();
+    ice_agent.add_remote_candidate(remote_candidate)?;
+
+    ice_agent.start_connectivity_checks(
+        Instant::now(),
+        cli.controlling,
+        remote_ufrag,
+        remote_pwd,
+    )?;
+
+    println!("Enter bye to stop");
+    let (mut tx, mut rx) = futures::channel::mpsc::channel(8);
+    std::thread::spawn(move || {
+        let mut buffer = String::new();
+        while io::stdin().read_line(&mut buffer).is_ok() {
+            match buffer.trim_end() {
+                "" => break,
+                line => {
+                    if line == "bye" {
+                        let _ = done_tx.send(());
+                        break;
+                    }
+                    if tx.try_send(line.to_string()).is_err() {
+                        break;
+                    }
+                }
+            };
+            buffer.clear();
+        }
+    });
+
+    // Start the ICE Agent. One side must be controlled, and the other must be controlling
+    let mut buf = vec![0u8; 2048];
+    loop {
+        while let Some(transmit) = ice_agent.poll_write() {
+            udp_socket
+                .send_to(&transmit.message[..], transmit.transport.peer_addr)
+                .await?;
+        }
+        let mut is_failed = false;
+        while let Some(event) = ice_agent.poll_event() {
+            match event.event {
+                Event::ConnectionStateChange(cs) => {
+                    println!("ConnectionStateChange with {}", cs);
+                    match cs {
+                        ConnectionState::Failed => {
+                            is_failed = true;
+                            break;
+                        }
+                        _ => {}
+                    }
+                }
+                _ => {}
+            }
+        }
+        if is_failed {
+            break;
+        }
+
+        let d = if let Some(eto) = ice_agent.poll_timeout() {
+            eto.duration_since(Instant::now())
+        } else {
+            Duration::from_millis(100)
+        };
+        let timeout = tokio::time::sleep(d);
+        tokio::pin!(timeout);
+
+        tokio::select! {
+            _ = done_rx.changed() => {
+                println!("exit ICE loop");
+                break;
+            }
+            _ = timeout.as_mut() => {
+                ice_agent.handle_timeout(Instant::now())?;
+            }
+            res = udp_socket.recv_from(&mut buf) => {
+                if let Ok((n, remote_addr)) = res {
+                    if n == 0 {
+                        break;
+                    }
+
+                    if stun::message::is_stun_message(&buf[0..n]) {
+                        ice_agent.handle_read(TransportMessage::<BytesMut>{
+                            now: Instant::now(),
+                            transport: TransportContext{
+                                local_addr: udp_socket.local_addr()?,
+                                peer_addr: remote_addr,
+                                ecn: None,
+                                transport_protocol: TransportProtocol::UDP,
+                            },
+                            message:BytesMut::from(&buf[0..n]),
+                        })?;
+                    } else {
+                        println!("{}", String::from_utf8((&buf[0..n]).to_vec())?);
+                    }
+                }
+            }
+            res = rx.next() => {
+                if let Some(line) = res {
+                    udp_socket.send_to(line.as_bytes(), peer_addr).await?;
+                }
+            }
+        };
+    }
+
+    ice_agent.close()?;
+
+    Ok(())
+}

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(())
+    }
+}