feat: support SNI multiaddrs in WebSocket transport

Adds support for WebSocket dialing with multiaddrs of the form:

```
/ip4/…/tcp/…/tls/sni/<hostname>/ws
```

This enables `rust-libp2p` nodes to connect to WSS peers using SNI-based addressing, as introduced in the libp2p specs for autotls support.

Pull-Request: #6041.

Author: rose2221

Cargo.lock

@@ -112,7 +112,7 @@ libp2p-upnp = { version = "0.5.0", path = "protocols/upnp" }
 libp2p-webrtc = { version = "0.9.0-alpha.1", path = "transports/webrtc" }
 libp2p-webrtc-utils = { version = "0.4.0", path = "misc/webrtc-utils" }
 libp2p-webrtc-websys = { version = "0.4.0", path = "transports/webrtc-websys" }
-libp2p-websocket = { version = "0.45.1", path = "transports/websocket" }
+libp2p-websocket = { version = "0.45.2", path = "transports/websocket" }
 libp2p-websocket-websys = { version = "0.5.0", path = "transports/websocket-websys" }
 libp2p-webtransport-websys = { version = "0.5.1", path = "transports/webtransport-websys" }
 libp2p-yamux = { version = "0.47.0", path = "muxers/yamux" }

Cargo.toml

@@ -1,3 +1,8 @@
+## 0.45.2
+
+- feat(websocket): support `/tls/sni/<hostname>/ws` multiaddrs in the WebSocket transport
+  See [PR 6041](https://github.com/your-username/rust-libp2p/pull/6041)
+
 ## 0.45.1
 - Rename types to match naming convention in [discussion 2174](https://github.com/libp2p/rust-libp2p/discussions/2174).
   See [PR 5873](https://github.com/libp2p/rust-libp2p/pull/5873).

transports/websocket/CHANGELOG.md

@@ -3,7 +3,7 @@ name = "libp2p-websocket"
 edition.workspace = true
 rust-version = { workspace = true }
 description = "WebSocket transport for libp2p"
-version = "0.45.1"
+version = "0.45.2"
 authors = ["Parity Technologies <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"

transports/websocket/Cargo.toml

@@ -508,7 +508,7 @@ fn parse_ws_dial_addr<T>(addr: Multiaddr) -> Result<WsAddress, Error<T>> {
     let mut protocols = addr.iter();
     let mut ip = protocols.next();
     let mut tcp = protocols.next();
-    let (host_port, server_name) = loop {
+    let (host_port, mut server_name) = loop {
         match (ip, tcp) {
             (Some(Protocol::Ip4(ip)), Some(Protocol::Tcp(port))) => {
                 let server_name = ServerName::IpAddress(IpAddr::V4(ip).into());
@@ -531,6 +531,8 @@ fn parse_ws_dial_addr<T>(addr: Multiaddr) -> Result<WsAddress, Error<T>> {
         }
     };
 
+    // Will hold a value if the multiaddr carries `/tls/sni/<host>`.
+    let mut sni_override: Option<ServerName<'static>> = None;
     // Now consume the `Ws` / `Wss` protocol from the end of the address,
     // preserving the trailing `P2p` protocol that identifies the remote,
     // if any.
@@ -540,6 +542,13 @@ fn parse_ws_dial_addr<T>(addr: Multiaddr) -> Result<WsAddress, Error<T>> {
         match protocols.pop() {
             p @ Some(Protocol::P2p(_)) => p2p = p,
             Some(Protocol::Ws(path)) => match protocols.pop() {
+                Some(Protocol::Sni(domain)) => match protocols.pop() {
+                    Some(Protocol::Tls) => {
+                        sni_override = Some(tls::dns_name_ref(&domain)?);
+                        break (true, path.into_owned());
+                    }
+                    _ => return Err(Error::InvalidMultiaddr(addr)),
+                },
                 Some(Protocol::Tls) => break (true, path.into_owned()),
                 Some(p) => {
                     protocols.push(p);
@@ -559,6 +568,9 @@ fn parse_ws_dial_addr<T>(addr: Multiaddr) -> Result<WsAddress, Error<T>> {
         None => protocols,
     };
 
+    if let Some(name) = sni_override {
+        server_name = name;
+    }
     Ok(WsAddress {
         host_port,
         server_name,
@@ -1013,5 +1025,49 @@ mod tests {
         // Check non-ws address
         let addr = "/ip4/127.0.0.1/tcp/2222".parse::<Multiaddr>().unwrap();
         parse_ws_dial_addr::<io::Error>(addr).unwrap_err();
+
+        // Check `/tls/sni/.../ws` with `/dns4`
+        let addr = "/dns4/example.com/tcp/2222/tls/sni/example.com/ws"
+            .parse::<Multiaddr>()
+            .unwrap();
+        let info = parse_ws_dial_addr::<io::Error>(addr).unwrap();
+        assert_eq!(info.host_port, "example.com:2222");
+        assert_eq!(info.path, "/");
+        assert!(info.use_tls);
+        assert_eq!(info.server_name, "example.com".try_into().unwrap());
+        assert_eq!(info.tcp_addr, "/dns4/example.com/tcp/2222".parse().unwrap());
+
+        // Check `/tls/sni/.../ws` with `/ip4`
+        let addr = "/ip4/127.0.0.1/tcp/2222/tls/sni/example.test/ws"
+            .parse::<Multiaddr>()
+            .unwrap();
+        let info = parse_ws_dial_addr::<io::Error>(addr).unwrap();
+        assert_eq!(info.host_port, "127.0.0.1:2222");
+        assert_eq!(info.path, "/");
+        assert!(info.use_tls);
+        assert_eq!(info.server_name, "example.test".try_into().unwrap());
+        assert_eq!(info.tcp_addr, "/ip4/127.0.0.1/tcp/2222".parse().unwrap());
+
+        // Check `/tls/sni/.../ws` with trailing `/p2p`
+        let addr = format!("/dns4/example.com/tcp/2222/tls/sni/example.com/ws/p2p/{peer_id}")
+            .parse()
+            .unwrap();
+        let info = parse_ws_dial_addr::<io::Error>(addr).unwrap();
+        assert_eq!(info.host_port, "example.com:2222");
+        assert_eq!(info.path, "/");
+        assert!(info.use_tls);
+        assert_eq!(info.server_name, "example.com".try_into().unwrap());
+        assert_eq!(
+            info.tcp_addr,
+            format!("/dns4/example.com/tcp/2222/p2p/{peer_id}")
+                .parse()
+                .unwrap()
+        );
+
+        // Negative: `/tls/sni/...` *without* `/ws` → error
+        let bad = "/dns4/example.com/tcp/2222/tls/sni/example.com"
+            .parse::<Multiaddr>()
+            .unwrap();
+        parse_ws_dial_addr::<io::Error>(bad).unwrap_err();
     }
 }