feat(websocket): add WebSocket for WASM environments

CHANGELOG.md

@@ -32,10 +32,11 @@
 - [`libp2p-pnet` CHANGELOG](transports/pnet/CHANGELOG.md)
 - [`libp2p-quic` CHANGELOG](transports/quic/CHANGELOG.md)
 - [`libp2p-tcp` CHANGELOG](transports/tcp/CHANGELOG.md)
+- [`libp2p-tls` CHANGELOG](transports/tls/CHANGELOG.md)
 - [`libp2p-uds` CHANGELOG](transports/uds/CHANGELOG.md)
 - [`libp2p-wasm-ext` CHANGELOG](transports/wasm-ext/CHANGELOG.md)
 - [`libp2p-websocket` CHANGELOG](transports/websocket/CHANGELOG.md)
-- [`libp2p-tls` CHANGELOG](transports/tls/CHANGELOG.md)
+- [`libp2p-websocket-websys` CHANGELOG](transports/websocket-websys/CHANGELOG.md)
 
 ## Multiplexers
 

Cargo.toml

@@ -58,6 +58,7 @@ members = [
     "transports/webrtc",
     "transports/websocket",
     "transports/webtransport-websys",
+    "transports/websocket-websys",
     "wasm-tests/webtransport-tests",
 ]
 resolver = "2"
@@ -66,7 +67,7 @@ resolver = "2"
 rust-version = "1.65.0"
 
 [workspace.dependencies]
-libp2p = { version = "0.52.3", path = "libp2p" }
+libp2p = { version = "0.52.4", path = "libp2p" }
 libp2p-allow-block-list = { version = "0.2.0", path = "misc/allow-block-list" }
 libp2p-autonat = { version = "0.11.0", path = "protocols/autonat" }
 libp2p-connection-limits = { version = "0.2.1", path = "misc/connection-limits" }
@@ -104,6 +105,7 @@ libp2p-uds = { version = "0.39.0", path = "transports/uds" }
 libp2p-wasm-ext = { version = "0.40.0", path = "transports/wasm-ext" }
 libp2p-webrtc = { version = "0.6.0-alpha", path = "transports/webrtc" }
 libp2p-websocket = { version = "0.42.1", path = "transports/websocket" }
+libp2p-websocket-websys = { version = "0.2.0", path = "transports/websocket-websys" }
 libp2p-webtransport-websys = { version = "0.1.0", path = "transports/webtransport-websys" }
 libp2p-yamux = { version = "0.44.1", path = "muxers/yamux" }
 multistream-select = { version = "0.13.0", path = "misc/multistream-select" }

interop-tests/Cargo.toml

@@ -33,7 +33,8 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-libp2p = { path = "../libp2p", features = ["ping", "macros", "webtransport-websys", "wasm-bindgen", "identify"] }
+libp2p = { path = "../libp2p", features = ["ping", "macros", "webtransport-websys", "wasm-bindgen", "identify", "websocket-websys", "yamux", "noise"] }
+libp2p-mplex = { path = "../muxers/mplex" }
 wasm-bindgen = { version = "0.2" }
 wasm-bindgen-futures = { version = "0.4" }
 wasm-logger = { version = "0.2.0" }

interop-tests/chromium-ping-version.json

@@ -1,7 +1,7 @@
 {
   "id": "chromium-rust-libp2p-head",
   "containerImageID": "chromium-rust-libp2p-head",
-  "transports": [{ "name": "webtransport", "onlyDial": true }],
-  "secureChannels": [],
-  "muxers": []
+  "transports": [{ "name": "webtransport", "onlyDial": true }, { "name": "ws", "onlyDial": true }],
+  "secureChannels": ["noise"],
+  "muxers": ["mplex", "yamux"]
 }

interop-tests/src/arch.rs

@@ -17,7 +17,6 @@ pub(crate) mod native {
     use std::time::Duration;
 
     use anyhow::{bail, Context, Result};
-    use either::Either;
     use env_logger::{Env, Target};
     use futures::future::BoxFuture;
     use futures::FutureExt;
@@ -31,7 +30,7 @@ pub(crate) mod native {
     use libp2p_webrtc as webrtc;
     use redis::AsyncCommands;
 
-    use crate::{from_env, Muxer, SecProtocol, Transport};
+    use crate::{Muxer, SecProtocol, Transport};
 
     use super::BoxedTransport;
 
@@ -47,66 +46,103 @@ pub(crate) mod native {
         tokio::time::sleep(duration).boxed()
     }
 
-    fn muxer_protocol_from_env() -> Result<Either<yamux::Config, mplex::MplexConfig>> {
-        Ok(match from_env("muxer")? {
-            Muxer::Yamux => Either::Left(yamux::Config::default()),
-            Muxer::Mplex => Either::Right(mplex::MplexConfig::new()),
-        })
-    }
-
     pub(crate) fn build_transport(
         local_key: Keypair,
         ip: &str,
         transport: Transport,
+        sec_protocol: Option<SecProtocol>,
+        muxer: Option<Muxer>,
     ) -> Result<(BoxedTransport, String)> {
-        let (transport, addr) = match (transport, from_env::<SecProtocol>("security")) {
-            (Transport::QuicV1, _) => (
+        let (transport, addr) = match (transport, sec_protocol, muxer) {
+            (Transport::QuicV1, _, _) => (
                 quic::tokio::Transport::new(quic::Config::new(&local_key))
                     .map(|(p, c), _| (p, StreamMuxerBox::new(c)))
                     .boxed(),
                 format!("/ip4/{ip}/udp/0/quic-v1"),
             ),
-            (Transport::Tcp, Ok(SecProtocol::Tls)) => (
+            (Transport::Tcp, Some(SecProtocol::Tls), Some(Muxer::Mplex)) => (
+                tcp::tokio::Transport::new(tcp::Config::new())
+                    .upgrade(Version::V1Lazy)
+                    .authenticate(tls::Config::new(&local_key).context("failed to initialise tls")?)
+                    .multiplex(mplex::MplexConfig::new())
+                    .timeout(Duration::from_secs(5))
+                    .boxed(),
+                format!("/ip4/{ip}/tcp/0"),
+            ),
+            (Transport::Tcp, Some(SecProtocol::Tls), Some(Muxer::Yamux)) => (
                 tcp::tokio::Transport::new(tcp::Config::new())
                     .upgrade(Version::V1Lazy)
                     .authenticate(tls::Config::new(&local_key).context("failed to initialise tls")?)
-                    .multiplex(muxer_protocol_from_env()?)
+                    .multiplex(yamux::Config::default())
                     .timeout(Duration::from_secs(5))
                     .boxed(),
                 format!("/ip4/{ip}/tcp/0"),
             ),
-            (Transport::Tcp, Ok(SecProtocol::Noise)) => (
+            (Transport::Tcp, Some(SecProtocol::Noise), Some(Muxer::Mplex)) => (
                 tcp::tokio::Transport::new(tcp::Config::new())
                     .upgrade(Version::V1Lazy)
                     .authenticate(
                         noise::Config::new(&local_key).context("failed to intialise noise")?,
                     )
-                    .multiplex(muxer_protocol_from_env()?)
+                    .multiplex(mplex::MplexConfig::new())
                     .timeout(Duration::from_secs(5))
                     .boxed(),
                 format!("/ip4/{ip}/tcp/0"),
             ),
-            (Transport::Ws, Ok(SecProtocol::Tls)) => (
+            (Transport::Tcp, Some(SecProtocol::Noise), Some(Muxer::Yamux)) => (
+                tcp::tokio::Transport::new(tcp::Config::new())
+                    .upgrade(Version::V1Lazy)
+                    .authenticate(
+                        noise::Config::new(&local_key).context("failed to intialise noise")?,
+                    )
+                    .multiplex(yamux::Config::default())
+                    .timeout(Duration::from_secs(5))
+                    .boxed(),
+                format!("/ip4/{ip}/tcp/0"),
+            ),
+            (Transport::Ws, Some(SecProtocol::Tls), Some(Muxer::Mplex)) => (
                 WsConfig::new(tcp::tokio::Transport::new(tcp::Config::new()))
                     .upgrade(Version::V1Lazy)
                     .authenticate(tls::Config::new(&local_key).context("failed to initialise tls")?)
-                    .multiplex(muxer_protocol_from_env()?)
+                    .multiplex(mplex::MplexConfig::new())
+                    .timeout(Duration::from_secs(5))
+                    .boxed(),
+                format!("/ip4/{ip}/tcp/0/ws"),
+            ),
+            (Transport::Ws, Some(SecProtocol::Tls), Some(Muxer::Yamux)) => (
+                WsConfig::new(tcp::tokio::Transport::new(tcp::Config::new()))
+                    .upgrade(Version::V1Lazy)
+                    .authenticate(
+                        tls::Config::new(&local_key).context("failed to intialise noise")?,
+                    )
+                    .multiplex(yamux::Config::default())
                     .timeout(Duration::from_secs(5))
                     .boxed(),
                 format!("/ip4/{ip}/tcp/0/ws"),
             ),
-            (Transport::Ws, Ok(SecProtocol::Noise)) => (
+            (Transport::Ws, Some(SecProtocol::Noise), Some(Muxer::Mplex)) => (
+                WsConfig::new(tcp::tokio::Transport::new(tcp::Config::new()))
+                    .upgrade(Version::V1Lazy)
+                    .authenticate(
+                        noise::Config::new(&local_key).context("failed to initialise tls")?,
+                    )
+                    .multiplex(mplex::MplexConfig::new())
+                    .timeout(Duration::from_secs(5))
+                    .boxed(),
+                format!("/ip4/{ip}/tcp/0/ws"),
+            ),
+            (Transport::Ws, Some(SecProtocol::Noise), Some(Muxer::Yamux)) => (
                 WsConfig::new(tcp::tokio::Transport::new(tcp::Config::new()))
                     .upgrade(Version::V1Lazy)
                     .authenticate(
                         noise::Config::new(&local_key).context("failed to intialise noise")?,
                     )
-                    .multiplex(muxer_protocol_from_env()?)
+                    .multiplex(yamux::Config::default())
                     .timeout(Duration::from_secs(5))
                     .boxed(),
                 format!("/ip4/{ip}/tcp/0/ws"),
             ),
-            (Transport::WebRtcDirect, _) => (
+            (Transport::WebRtcDirect, _, _) => (
                 webrtc::tokio::Transport::new(
                     local_key,
                     webrtc::tokio::Certificate::generate(&mut rand::thread_rng())?,
@@ -115,9 +151,13 @@ pub(crate) mod native {
                 .boxed(),
                 format!("/ip4/{ip}/udp/0/webrtc-direct"),
             ),
-            (Transport::Tcp, Err(_)) => bail!("Missing security protocol for TCP transport"),
-            (Transport::Ws, Err(_)) => bail!("Missing security protocol for Websocket transport"),
-            (Transport::Webtransport, _) => bail!("Webtransport can only be used with wasm"),
+            (Transport::Webtransport, _, _) => bail!("Webtransport can only be used with wasm"),
+            (Transport::Tcp | Transport::Ws, None, _) => {
+                bail!("Missing security protocol for {transport:?}")
+            }
+            (Transport::Tcp | Transport::Ws, _, None) => {
+                bail!("Missing muxer protocol for {transport:?}")
+            }
         };
         Ok((transport, addr))
     }
@@ -154,14 +194,16 @@ pub(crate) mod native {
 
 #[cfg(target_arch = "wasm32")]
 pub(crate) mod wasm {
-    use anyhow::{bail, Result};
+    use anyhow::{bail, Context, Result};
     use futures::future::{BoxFuture, FutureExt};
+    use libp2p::core::upgrade::Version;
     use libp2p::identity::Keypair;
     use libp2p::swarm::{NetworkBehaviour, SwarmBuilder};
-    use libp2p::PeerId;
+    use libp2p::{noise, yamux, PeerId, Transport as _};
+    use libp2p_mplex as mplex;
     use std::time::Duration;
 
-    use crate::{BlpopRequest, Transport};
+    use crate::{BlpopRequest, Muxer, SecProtocol, Transport};
 
     use super::BoxedTransport;
 
@@ -180,18 +222,52 @@ pub(crate) mod wasm {
         local_key: Keypair,
         ip: &str,
         transport: Transport,
+        sec_protocol: Option<SecProtocol>,
+        muxer: Option<Muxer>,
     ) -> Result<(BoxedTransport, String)> {
-        if let Transport::Webtransport = transport {
-            Ok((
+        Ok(match (transport, sec_protocol, muxer) {
+            (Transport::Webtransport, _, _) => (
                 libp2p::webtransport_websys::Transport::new(
                     libp2p::webtransport_websys::Config::new(&local_key),
                 )
                 .boxed(),
                 format!("/ip4/{ip}/udp/0/quic/webtransport"),
-            ))
-        } else {
-            bail!("Only webtransport supported with wasm")
-        }
+            ),
+            (Transport::Ws, Some(SecProtocol::Noise), Some(Muxer::Mplex)) => (
+                libp2p::websocket_websys::Transport::default()
+                    .upgrade(Version::V1Lazy)
+                    .authenticate(
+                        noise::Config::new(&local_key).context("failed to initialise noise")?,
+                    )
+                    .multiplex(mplex::MplexConfig::new())
+                    .timeout(Duration::from_secs(5))
+                    .boxed(),
+                format!("/ip4/{ip}/tcp/0/wss"),
+            ),
+            (Transport::Ws, Some(SecProtocol::Noise), Some(Muxer::Yamux)) => (
+                libp2p::websocket_websys::Transport::default()
+                    .upgrade(Version::V1Lazy)
+                    .authenticate(
+                        noise::Config::new(&local_key).context("failed to initialise noise")?,
+                    )
+                    .multiplex(yamux::Config::default())
+                    .timeout(Duration::from_secs(5))
+                    .boxed(),
+                format!("/ip4/{ip}/tcp/0/wss"),
+            ),
+            (Transport::Ws, None, _) => {
+                bail!("Missing security protocol for WS")
+            }
+            (Transport::Ws, Some(SecProtocol::Tls), _) => {
+                bail!("TLS not supported in WASM")
+            }
+            (Transport::Ws, _, None) => {
+                bail!("Missing muxer protocol for WS")
+            }
+            (Transport::WebRtcDirect | Transport::QuicV1 | Transport::Tcp, _, _) => {
+                bail!("{transport:?} is not supported in WASM")
+            }
+        })
     }
 
     pub(crate) fn swarm_builder<TBehaviour: NetworkBehaviour>(

interop-tests/src/bin/config/mod.rs

@@ -5,6 +5,8 @@ use anyhow::{Context, Result};
 #[derive(Debug, Clone)]
 pub(crate) struct Config {
     pub(crate) transport: String,
+    pub(crate) sec_protocol: Option<String>,
+    pub(crate) muxer: Option<String>,
     pub(crate) ip: String,
     pub(crate) is_dialer: bool,
     pub(crate) test_timeout: u64,
@@ -26,8 +28,13 @@ impl Config {
             .map(|addr| format!("redis://{addr}"))
             .unwrap_or_else(|_| "redis://redis:6379".into());
 
+        let sec_protocol = env::var("security").ok();
+        let muxer = env::var("muxer").ok();
+
         Ok(Self {
             transport,
+            sec_protocol,
+            muxer,
             ip,
             is_dialer,
             test_timeout,

interop-tests/src/bin/native_ping.rs

@@ -12,6 +12,8 @@ async fn main() -> Result<()> {
         config.is_dialer,
         config.test_timeout,
         &config.redis_addr,
+        config.sec_protocol,
+        config.muxer,
     )
     .await?;
 

interop-tests/src/bin/wasm_ping.rs

@@ -178,8 +178,14 @@ async fn serve_index_html(state: State<TestState>) -> Result<impl IntoResponse,
         ip,
         is_dialer,
         test_timeout,
+        sec_protocol,
+        muxer,
         ..
     } = state.0.config;
+
+    let sec_protocol = sec_protocol.unwrap_or("null".to_owned());
+    let muxer = muxer.unwrap_or("null".to_owned());
+
     Ok(Html(format!(
         r#"
         <!DOCTYPE html>
@@ -199,7 +205,9 @@ async fn serve_index_html(state: State<TestState>) -> Result<impl IntoResponse,
                     "{ip}",
                     {is_dialer},
                     "{test_timeout}",
-                    "{BIND_ADDR}"
+                    "{BIND_ADDR}",
+                    "{sec_protocol}",
+                    "{muxer}"
                 )
             </script>
         </head>