varun-r-mallya/py-libp2p
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/py-libp2p.git synced 2025-12-31 20:36:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix IPv6 host bracketing in WebSocket transport

Browse Source
This commit is contained in:
GautamBytes
2025-07-23 08:10:51 +00:00
parent 8a21435fc4
commit 1997777c52
6 changed files with 73 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
libp2p/transport/websocket/listener.py
View File

@ -38,7 +38,10 @@ class WebsocketListener(IListener):
or maddr.value_for_protocol("dns6")
or "0.0.0.0"
)
port = int(maddr.value_for_protocol("tcp"))
port_str = maddr.value_for_protocol("tcp")
if port_str is None:
raise ValueError(f"No TCP port found in multiaddr: {maddr}")
port = int(port_str)
async def serve(
task_status: TaskStatus[Any] = trio.TASK_STATUS_IGNORED,

38
libp2p/transport/websocket/transport.py
View File

@ -16,24 +16,38 @@ class WebsocketTransport(ITransport):
"""
async def dial(self, maddr: Multiaddr) -> RawConnection:
text = str(maddr)
if text.endswith("/wss"):
# Handle addresses with /p2p/ PeerID suffix by truncating them at /ws
addr_text = str(maddr)
try:
ws_part_index = addr_text.index("/ws")
# Create a new Multiaddr containing only the transport part
transport_maddr = Multiaddr(addr_text[: ws_part_index + 3])
except ValueError:
raise ValueError(
f"WebsocketTransport requires a /ws protocol, not found in {maddr}"
) from None
# Check for /wss, which is not supported yet
if str(transport_maddr).endswith("/wss"):
raise NotImplementedError("/wss (TLS) not yet supported")
if not text.endswith("/ws"):
raise ValueError(f"WebsocketTransport only supports /ws, got {maddr}")
host = (
maddr.value_for_protocol("ip4")
or maddr.value_for_protocol("ip6")
or maddr.value_for_protocol("dns")
or maddr.value_for_protocol("dns4")
or maddr.value_for_protocol("dns6")
transport_maddr.value_for_protocol("ip4")
or transport_maddr.value_for_protocol("ip6")
or transport_maddr.value_for_protocol("dns")
or transport_maddr.value_for_protocol("dns4")
or transport_maddr.value_for_protocol("dns6")
)
if host is None:
raise ValueError(f"No host protocol found in {maddr}")
raise ValueError(f"No host protocol found in {transport_maddr}")
port = int(maddr.value_for_protocol("tcp"))
uri = f"ws://{host}:{port}"
port_str = transport_maddr.value_for_protocol("tcp")
if port_str is None:
raise ValueError(f"No TCP port found in multiaddr: {transport_maddr}")
port = int(port_str)
host_str = f"[{host}]" if ":" in host else host
uri = f"ws://{host_str}:{port}"
try:
async with open_websocket_url(uri, ssl_context=None) as ws:

2
tests/interop/js_libp2p/js_node/src/package.json
View File

@ -12,6 +12,8 @@
"dependencies": {
"@libp2p/ping": "^2.0.36",
"@libp2p/websockets": "^9.2.18",
"@chainsafe/libp2p-yamux": "^5.0.1",
"@libp2p/plaintext": "^2.0.7",
"libp2p": "^2.9.0",
"multiaddr": "^10.0.1"
}

8
tests/interop/js_libp2p/js_node/src/ws_ping_node.mjs
View File

@ -1,20 +1,20 @@
import { createLibp2p } from 'libp2p'
import { webSockets } from '@libp2p/websockets'
import { ping } from '@libp2p/ping'
import { plaintext } from '@libp2p/insecure'
import { mplex } from '@libp2p/mplex'
import { plaintext } from '@libp2p/plaintext'
import { yamux } from '@chainsafe/libp2p-yamux'
async function main() {
const node = await createLibp2p({
transports: [ webSockets() ],
connectionEncryption: [ plaintext() ],
streamMuxers: [ mplex() ],
streamMuxers: [ yamux() ],
services: {
// installs /ipfs/ping/1.0.0 handler
ping: ping()
},
addresses: {
listen: ['/ip4/127.0.0.1/tcp/0/ws']
listen: ['/ip4/0.0.0.0/tcp/0/ws']
}
})

47
tests/interop/test_js_ws_ping.py
View File

@ -10,12 +10,13 @@ from trio.lowlevel import open_process
from libp2p.crypto.secp256k1 import create_new_key_pair
from libp2p.custom_types import TProtocol
from libp2p.host.basic_host import BasicHost
from libp2p.network.exceptions import SwarmException
from libp2p.network.swarm import Swarm
from libp2p.peer.id import ID
from libp2p.peer.peerinfo import PeerInfo
from libp2p.peer.peerstore import PeerStore
from libp2p.security.insecure.transport import InsecureTransport
from libp2p.stream_muxer.mplex.mplex import MPLEX_PROTOCOL_ID, Mplex
from libp2p.stream_muxer.yamux.yamux import Yamux
from libp2p.transport.upgrader import TransportUpgrader
from libp2p.transport.websocket.transport import WebsocketTransport
@ -24,10 +25,20 @@ PLAINTEXT_PROTOCOL_ID = "/plaintext/1.0.0"
@pytest.mark.trio
async def test_ping_with_js_node():
# Path to the JS node script
js_node_dir = os.path.join(os.path.dirname(__file__), "js_libp2p", "js_node", "src")
script_name = "./ws_ping_node.mjs"
try:
subprocess.run(
["npm", "install"],
cwd=js_node_dir,
check=True,
capture_output=True,
text=True,
)
except (subprocess.CalledProcessError, FileNotFoundError) as e:
pytest.fail(f"Failed to run 'npm install': {e}")
# Launch the JS libp2p node (long-running)
proc = await open_process(
["node", script_name],
@ -35,22 +46,25 @@ async def test_ping_with_js_node():
stderr=subprocess.PIPE,
cwd=js_node_dir,
)
assert proc.stdout is not None, "stdout pipe missing"
assert proc.stderr is not None, "stderr pipe missing"
stdout = proc.stdout
stderr = proc.stderr
try:
# Read first two lines (PeerID and multiaddr)
buffer = b""
with trio.fail_after(10):
with trio.fail_after(30):
while buffer.count(b"\n") < 2:
chunk = await proc.stdout.receive_some(1024) # type: ignore
chunk = await stdout.receive_some(1024)
if not chunk:
break
buffer += chunk
# Split and filter out any empty lines
lines = [line for line in buffer.decode().splitlines() if line.strip()]
if len(lines) < 2:
stderr_output = ""
if proc.stderr is not None:
stderr_output = (await proc.stderr.receive_some(2048)).decode()
stderr_output = await stderr.receive_some(2048)
stderr_output = stderr_output.decode()
pytest.fail(
"JS node did not produce expected PeerID and multiaddr.\n"
f"Stdout: {buffer.decode()!r}\n"
@ -70,7 +84,7 @@ async def test_ping_with_js_node():
secure_transports_by_protocol={
TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair)
},
muxer_transports_by_protocol={TProtocol(MPLEX_PROTOCOL_ID): Mplex},
muxer_transports_by_protocol={TProtocol("/yamux/1.0.0"): Yamux},
)
transport = WebsocketTransport()
swarm = Swarm(py_peer_id, peer_store, upgrader, transport)
@ -78,9 +92,19 @@ async def test_ping_with_js_node():
# Connect to JS node
peer_info = PeerInfo(peer_id, [maddr])
await host.connect(peer_info)
await trio.sleep(1)
try:
await host.connect(peer_info)
except SwarmException as e:
underlying_error = e.__cause__
pytest.fail(
"Connection failed with SwarmException.\n"
f"THE REAL ERROR IS: {underlying_error!r}\n"
)
assert host.get_network().connections.get(peer_id) is not None
await trio.sleep(0.1)
# Ping protocol
stream = await host.new_stream(peer_id, [TProtocol("/ipfs/ping/1.0.0")])
@ -88,7 +112,6 @@ async def test_ping_with_js_node():
data = await stream.read(4)
assert data == b"pong"
# Cleanup
await host.close()
finally:
proc.send_signal(signal.SIGTERM)

4
tests/transport/test_websocket.py
View File

@ -12,7 +12,7 @@ from libp2p.peer.id import ID
from libp2p.peer.peerinfo import PeerInfo
from libp2p.peer.peerstore import PeerStore
from libp2p.security.insecure.transport import InsecureTransport
from libp2p.stream_muxer.mplex.mplex import MPLEX_PROTOCOL_ID, Mplex
from libp2p.stream_muxer.yamux.yamux import Yamux
from libp2p.transport.upgrader import TransportUpgrader
from libp2p.transport.websocket.transport import WebsocketTransport
@ -33,7 +33,7 @@ async def make_host(
secure_transports_by_protocol={
TProtocol(PLAINTEXT_PROTOCOL_ID): InsecureTransport(key_pair)
},
muxer_transports_by_protocol={TProtocol(MPLEX_PROTOCOL_ID): Mplex},
muxer_transports_by_protocol={TProtocol("/yamux/1.0.0"): Yamux},
)
# Transport + Swarm + Host