fix: listen on multiple wildcards (#32)

* fix: listen on multiple wildcards

Switches UDP port creation to use the socket2 crate - this lets us
configure ipv6 ports to only listen on ipv6 addresses and not be
dual stack (default on linux).

Fixes #28

* chore: remove unused var

Author: achingbrain

.gitignore

@@ -9,6 +9,7 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 lerna-debug.log*
+package-lock.json
 
 # Diagnostic reports (https://nodejs.org/api/report.html)
 report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json

package.json

@@ -69,6 +69,7 @@
     "uint8arraylist": "^2.4.8"
   },
   "devDependencies": {
+    "@chainsafe/is-ip": "^2.1.0",
     "@libp2p/interface-compliance-tests": "^6.3.2",
     "@libp2p/logger": "^5.0.1",
     "@napi-rs/cli": "^3.0.0-alpha.70",

rust/lib.rs

@@ -7,6 +7,7 @@ use std::{
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
 use tokio::sync::Mutex;
+use socket2::{Socket, Domain, Type};
 
 mod config;
 mod socket;
@@ -30,10 +31,20 @@ impl Server {
   pub fn new(config: &config::QuinnConfig, ip: String, port: u16) -> Result<Self> {
     let ip_addr = ip.parse::<IpAddr>().map_err(to_err)?;
     let socket_addr = SocketAddr::new(ip_addr, port);
-    let socket = socket::create_socket(config.socket_config, socket_addr)?;
+    let socket;
+
+    // Create a TCP listener bound to two addresses.
+    if ip_addr.is_ipv6() {
+      socket = Socket::new(Domain::IPV6, Type::DGRAM, None)?;
+      socket.set_only_v6(true)?;
+    } else {
+      socket = Socket::new(Domain::IPV4, Type::DGRAM, None)?;
+    }
+
+    socket.bind(&socket_addr.into())?;
 
-    let socket = block_on(async move{
-      socket::UdpSocket::wrap_udp_socket(socket)
+    let socket: Arc<socket::UdpSocket> = block_on(async move{
+      socket::UdpSocket::wrap_udp_socket(socket.into())
     })?;
     let endpoint = block_on(async {
       quinn::Endpoint::new_with_abstract_socket(

rust/socket.rs

@@ -23,12 +23,22 @@ use std::{
 use quinn::udp;
 use quinn::{AsyncUdpSocket, UdpPoller};
 use tokio::{io::Interest, sync::RwLock};
-use socket2::Socket;
+use socket2::{Socket, Domain, Type};
 
 use crate::config;
 
 pub fn create_socket(config: config::SocketConfig, socket_addr: std::net::SocketAddr) -> napi::Result<std::net::UdpSocket> {
-    let socket = std::net::UdpSocket::bind(socket_addr)?;
+    let socket;
+
+    // Create a TCP listener bound to two addresses.
+    if socket_addr.is_ipv6() {
+      socket = Socket::new(Domain::IPV6, Type::DGRAM, None)?;
+      socket.set_only_v6(true)?;
+    } else {
+      socket = Socket::new(Domain::IPV4, Type::DGRAM, None)?;
+    }
+
+    socket.bind(&socket_addr.into())?;
 
     let socket = Socket::from(socket);
     socket.set_send_buffer_size(config.send_buffer_size as usize).unwrap();

src/listener.ts

@@ -1,5 +1,5 @@
 import { setMaxListeners, TypedEventEmitter } from '@libp2p/interface'
-import { fromStringTuples } from '@multiformats/multiaddr'
+import { multiaddr } from '@multiformats/multiaddr'
 import { QuicConnection } from './connection.js'
 import * as napi from './napi.js'
 import { QuicStreamMuxerFactory } from './stream-muxer.js'
@@ -86,28 +86,28 @@ export class QuicListener extends TypedEventEmitter<ListenerEvents> implements L
     return []
   }
 
-  async listen (multiaddr: Multiaddr): Promise<void> {
-    const addr = multiaddr.nodeAddress()
+  async listen (ma: Multiaddr): Promise<void> {
+    const addr = ma.nodeAddress()
     const controller = new AbortController()
     const listener = new napi.Server(this.#config, addr.address, addr.port)
 
     // replace wildcard port with actual listening port
     if (addr.port === 0) {
-      const stringTuples = multiaddr.stringTuples()
+      const components = ma.getComponents()
 
-      for (const stringTuple of stringTuples) {
-        if (stringTuple[0] === 0x0111) {
-          stringTuple[1] = `${listener.port()}`
+      for (const component of components) {
+        if (component.name === 'udp') {
+          component.value = `${listener.port()}`
         }
       }
 
-      multiaddr = fromStringTuples(stringTuples)
+      ma = multiaddr(components)
     }
 
     this.state = {
       status: 'listening',
       listener,
-      listenAddr: multiaddr,
+      listenAddr: ma,
       controller,
       connections: new Set()
     }

test/transport.spec.ts

@@ -1,5 +1,6 @@
 /* eslint-env mocha */
 
+import { isIPv4, isIPv6 } from '@chainsafe/is-ip'
 import { generateKeyPair } from '@libp2p/crypto/keys'
 import { defaultLogger } from '@libp2p/logger'
 import { multiaddr } from '@multiformats/multiaddr'
@@ -14,14 +15,17 @@ import type { Multiaddr } from '@multiformats/multiaddr'
 
 describe('Quic Transport', () => {
   let components: QuicComponents
-  let listener: Listener
+  let listeners: Listener[]
 
   beforeEach(async () => {
+    listeners = []
     components = await createComponents()
   })
 
   afterEach(async () => {
-    await listener?.close()
+    await Promise.all(
+      listeners.map(l => l.close())
+    )
   })
 
   it('transport filter filters out invalid dial multiaddrs', async () => {
@@ -48,9 +52,10 @@ describe('Quic Transport', () => {
     }
 
     const transport = quic()(components)
-    listener = transport.createListener({
+    const listener = transport.createListener({
       upgrader: stubInterface<Upgrader>()
     })
+    listeners.push(listener)
 
     await Promise.all([
       pEvent(listener, 'listening'),
@@ -89,4 +94,90 @@ describe('Quic Transport', () => {
   it('supports listening on specific ipv6 addresses', async () => {
     await testListenAddresses(multiaddr('/ip6/::1/udp/0/quic-v1'), false)
   })
+
+  it('supports listening on multiple wildcards', async () => {
+    const components = {
+      logger: defaultLogger(),
+      privateKey: await generateKeyPair('Ed25519')
+    }
+
+    const transport = quic()(components)
+    const ip4Listener = transport.createListener({
+      upgrader: stubInterface<Upgrader>()
+    })
+    listeners.push(ip4Listener)
+    const ip6Listener = transport.createListener({
+      upgrader: stubInterface<Upgrader>()
+    })
+    listeners.push(ip6Listener)
+
+    await Promise.all([
+      pEvent(ip4Listener, 'listening'),
+      ip4Listener.listen(multiaddr('/ip4/0.0.0.0/udp/0/quic-v1')),
+      pEvent(ip6Listener, 'listening'),
+      ip6Listener.listen(multiaddr('/ip6/::/udp/0/quic-v1'))
+    ])
+
+    const addrs = [
+      ...ip4Listener.getAddrs(),
+      ...ip6Listener.getAddrs()
+    ]
+
+    let hadIp4 = false
+    let hadIp6 = false
+
+    for (const addr of addrs) {
+      const { host, port } = addr.toOptions()
+      expect(port).to.be.greaterThan(0, 'did not translate wildcard port')
+
+      if (isIPv4(host)) {
+        hadIp4 = true
+        expect(host).to.not.equal('0.0.0.0', 'did not translate wildcard host')
+      } else if (isIPv6(host)) {
+        hadIp6 = true
+        expect(host).to.not.equal('::', 'did not translate wildcard host')
+      } else {
+        throw new Error(`Host "${host}" was neither IPv4 nor IPv6`)
+      }
+    }
+
+    expect(hadIp4).to.be.true('did not listen on IPv4 addresses')
+    expect(hadIp6).to.be.true('did not listen on IPv6 addresses')
+  })
+
+  it('supports listening the same port for different families', async () => {
+    const components = {
+      logger: defaultLogger(),
+      privateKey: await generateKeyPair('Ed25519')
+    }
+
+    const transport = quic()(components)
+    const ip4Listener = transport.createListener({
+      upgrader: stubInterface<Upgrader>()
+    })
+    listeners.push(ip4Listener)
+    const ip6Listener = transport.createListener({
+      upgrader: stubInterface<Upgrader>()
+    })
+    listeners.push(ip6Listener)
+
+    await Promise.all([
+      pEvent(ip4Listener, 'listening'),
+      ip4Listener.listen(multiaddr('/ip4/127.0.0.1/udp/14000/quic-v1')),
+      pEvent(ip6Listener, 'listening'),
+      ip6Listener.listen(multiaddr('/ip6/::1/udp/14000/quic-v1'))
+    ])
+
+    const addrs = [
+      ...ip4Listener.getAddrs(),
+      ...ip6Listener.getAddrs()
+    ]
+
+    expect(addrs).to.have.lengthOf(2, 'did not listen on correct amount of addresses')
+
+    for (const addr of addrs) {
+      const { port } = addr.toOptions()
+      expect(port).to.equal(14000, 'did not listen on port')
+    }
+  })
 })