feat(iroh): add initial scaffolding for WebRTC support

iroh/Cargo.toml

@@ -101,6 +101,11 @@ tracing-subscriber = { version = "0.3", features = [
 ], optional = true }
 indicatif = { version = "0.18", features = ["tokio"], optional = true }
 parse-size = { version = "=1.0.0", optional = true, features = ['std'] } # pinned version to avoid bumping msrv to 1.81
+webrtc = "0.13.0"
+web-sys = "0.3.77"
+wasm-bindgen = "0.2.100"
+js-sys = "0.3.77"
+wasm-bindgen-futures = "0.4.50"
 
 
 # non-wasm-in-browser dependencies
@@ -130,6 +135,20 @@ wasm-bindgen-futures = "0.4"
 instant = { version = "0.1", features = ["wasm-bindgen"] }
 time = { version = "0.3", features = ["wasm-bindgen"] }
 getrandom = { version = "0.3.2", features = ["wasm_js"] }
+web-sys = {version="0.3.77" , optional = true, features = [
+
+    "RtcPeerConnection",
+    "RtcDataChannel",
+    "RtcConfiguration",
+    "RtcIceServer",
+    "RtcSessionDescription",
+    "RtcIceCandidate",
+    "RtcDataChannelInit",
+    "RtcPeerConnectionIceEvent",
+    "MessageEvent",
+
+]}
+
 
 # target-common test/dev dependencies
 [dev-dependencies]

iroh/src/disco.rs

@@ -24,13 +24,14 @@ use std::{
 };
 
 use data_encoding::HEXLOWER;
-use iroh_base::{PublicKey, RelayUrl};
+use iroh_base::{NodeId, PublicKey, RelayUrl};
 use nested_enum_utils::common_fields;
 use serde::{Deserialize, Serialize};
 use snafu::{Snafu, ensure};
 use url::Url;
 
 use crate::magicsock::transports;
+use crate::magicsock::transports::Addr;
 
 // TODO: custom magicn
 /// The 6 byte header of all discovery messages.
@@ -143,6 +144,8 @@ pub enum SendAddr {
     Udp(SocketAddr),
     /// Relay Url.
     Relay(RelayUrl),
+    /// Node Id
+    NodeId(NodeId)
 }
 
 impl SendAddr {
@@ -165,6 +168,7 @@ impl From<transports::Addr> for SendAddr {
         match addr {
             transports::Addr::Ip(addr) => SendAddr::Udp(addr),
             transports::Addr::Relay(url, _) => SendAddr::Relay(url),
+            Addr::WebRtc(relay_url, dest_id, channel_id) => SendAddr::
         }
     }
 }

iroh/src/magicsock.rs

@@ -60,7 +60,7 @@ use self::transports::IpTransport;
 use self::{
     metrics::Metrics as MagicsockMetrics,
     node_map::{NodeMap, PingAction, PingRole, SendPing},
-    transports::{RelayActorConfig, RelayTransport, Transports, UdpSender},
+    transports::{RelayActorConfig, RelayTransport, Transports, UdpSender, webrtc::*},
 };
 #[cfg(not(wasm_browser))]
 use crate::dns::DnsResolver;
@@ -657,6 +657,12 @@ impl MagicSock {
                                 .recv_data_relay
                                 .inc_by(datagram.len() as _);
                         }
+                        transports::Addr::WebRtc(..) => {
+                            self.metrics
+                                .magicsock
+                                .recv_data_webrtc
+                                .inc_by(datagram.len() as _);
+                        }
                     }
 
                     quic_datagram_count += 1;
@@ -719,6 +725,11 @@ impl MagicSock {
                         let quic_mapped_addr = self.node_map.receive_relay(src_url, *src_node);
                         quinn_meta.addr = quic_mapped_addr.private_socket_addr();
                     }
+                    transports::Addr::WebRtc(relay_url, node_id, channel_id) => {
+
+                    todo!("implemnet webrtc processing")
+
+                    }
                 }
             } else {
                 // If all datagrams in this buf are DISCO, set len to zero to make
@@ -1332,6 +1343,8 @@ pub enum CreateHandleError {
     CreateNetmonMonitor { source: netmon::Error },
     #[snafu(display("Failed to subscribe netmon monitor"))]
     SubscribeNetmonMonitor { source: netmon::Error },
+    #[snafu(display("Failed to create webrtc endpoint"))]
+    CreateWebRtcEndpoint { source: WebRtcError },
 }
 
 impl Handle {
@@ -1395,15 +1408,27 @@ impl Handle {
             metrics: metrics.magicsock.clone(),
         });
         let relay_transports = vec![relay_transport];
+        let web_rtc_transport = WebRtcTransport::new(WebRtcActorConfig {
+            node_id: secret_key.clone().public(),
+        })
+        .await
+        .context(CreateWebRtcEndpointSnafu)?;
+        let web_rtc_transports = vec![web_rtc_transport];
 
         let secret_encryption_key = secret_ed_box(secret_key.secret());
         #[cfg(not(wasm_browser))]
         let ipv6 = ip_transports.iter().any(|t| t.bind_addr().is_ipv6());
 
         #[cfg(not(wasm_browser))]
-        let transports = Transports::new(ip_transports, relay_transports, max_receive_segments);
+        let transports = Transports::new(
+            ip_transports,
+            relay_transports,
+            web_rtc_transports,
+            max_receive_segments,
+        );
         #[cfg(wasm_browser)]
-        let transports = Transports::new(relay_transports, max_receive_segments);
+        let transports =
+            Transports::new(relay_transports, web_rtc_transports, max_receive_segments);
 
         let (disco, disco_receiver) = DiscoState::new(secret_encryption_key);
 

iroh/src/magicsock/transports.rs

@@ -6,6 +6,7 @@ use std::{
     task::{Context, Poll},
 };
 
+use crate::magicsock::transports::webrtc::{WebRtcSender, WebRtcTransport};
 use iroh_base::{NodeId, RelayUrl};
 use n0_watcher::Watcher;
 use relay::{RelayNetworkChangeSender, RelaySender};
@@ -15,6 +16,7 @@ use tracing::{error, trace, warn};
 #[cfg(not(wasm_browser))]
 mod ip;
 mod relay;
+pub mod webrtc;
 
 #[cfg(not(wasm_browser))]
 pub(crate) use self::ip::IpTransport;
@@ -23,15 +25,14 @@ use self::ip::{IpNetworkChangeSender, IpSender};
 pub(crate) use self::relay::{RelayActorConfig, RelayTransport};
 use super::MagicSock;
 use crate::net_report::Report;
-
 /// Manages the different underlying data transports that the magicsock
 /// can support.
 #[derive(Debug)]
 pub(crate) struct Transports {
     #[cfg(not(wasm_browser))]
     ip: Vec<IpTransport>,
     relay: Vec<RelayTransport>,
-
+    web_rtc: Vec<WebRtcTransport>,
     max_receive_segments: Arc<AtomicUsize>,
     poll_recv_counter: AtomicUsize,
 }
@@ -62,12 +63,14 @@ impl Transports {
     pub(crate) fn new(
         #[cfg(not(wasm_browser))] ip: Vec<IpTransport>,
         relay: Vec<RelayTransport>,
+        web_rtc: Vec<WebRtcTransport>,
         max_receive_segments: Arc<AtomicUsize>,
     ) -> Self {
         Self {
             #[cfg(not(wasm_browser))]
             ip,
             relay,
+            web_rtc,
             max_receive_segments,
             poll_recv_counter: Default::default(),
         }
@@ -232,13 +235,15 @@ impl Transports {
         #[cfg(not(wasm_browser))]
         let ip = self.ip.iter().map(|t| t.create_sender()).collect();
         let relay = self.relay.iter().map(|t| t.create_sender()).collect();
+        let webrtc = self.web_rtc.iter().map(|t| t.create_sender()).collect();
         let max_transmit_segments = self.max_transmit_segments();
 
         UdpSender {
             #[cfg(not(wasm_browser))]
             ip,
             msock,
             relay,
+            webrtc,
             max_transmit_segments,
         }
     }
@@ -314,8 +319,12 @@ pub(crate) struct Transmit<'a> {
 pub(crate) enum Addr {
     Ip(SocketAddr),
     Relay(RelayUrl, NodeId),
+    WebRtc(RelayUrl, NodeId, ChannelId),
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ChannelId(Option<u16>);
+
 impl Default for Addr {
     fn default() -> Self {
         Self::Ip(SocketAddr::V6(SocketAddrV6::new(
@@ -349,6 +358,7 @@ impl Addr {
         match self {
             Self::Ip(ip) => Some(ip),
             Self::Relay(..) => None,
+            Self::WebRtc(relay_url, node_id, channel_id) => None,
         }
     }
 }
@@ -359,6 +369,7 @@ pub(crate) struct UdpSender {
     #[cfg(not(wasm_browser))]
     ip: Vec<IpSender>,
     relay: Vec<RelaySender>,
+    webrtc: Vec<WebRtcSender>,
     max_transmit_segments: usize,
 }
 
@@ -406,6 +417,19 @@ impl UdpSender {
                     }
                 }
             }
+            Addr::WebRtc(relay_url, node_id, channel_id) => {
+
+                for sender in &self.webrtc {
+                    match sender.send(*node_id,transmit, channel_id).await{
+                        Ok(()) => {
+                            return Ok(());
+                        }
+                        Err(err) => {
+                            warn!("webrtc failed to send: {:?}", err);
+                        }
+                    }
+                }
+            }
         }
         if any_match {
             Err(io::Error::other("all available transports failed"))
@@ -449,6 +473,17 @@ impl UdpSender {
                     }
                 }
             }
+            Addr::WebRtc(relay_url, node_id, channel_id) => {
+
+                for sender in &mut self.webrtc {
+                    match sender.poll_send(cx, *node_id, transmit, channel_id){
+                        Poll::Ready(res) => { return  Poll::Ready(res) },
+                        Poll::Pending => {}
+                    }
+                }
+
+            }
+
         }
         Poll::Pending
     }
@@ -490,6 +525,18 @@ impl UdpSender {
                     }
                 }
             }
+            Addr::WebRtc(relay_url, node_id, channel_id) => {
+                for transport in &self.webrtc {
+
+                    match transport.try_send(*node_id, transmit, channel_id) {
+                        Ok(()) => return Ok(()),
+                        Err(_err) => {
+                            continue;
+                        }
+                    }
+
+                }
+            }
         }
         Err(io::Error::new(
             io::ErrorKind::WouldBlock,