@libp2p/webrtc 5.1.1 → 5.2.0

package/src/private-to-public/listener.ts

@@ -1,8 +1,8 @@
 import { networkInterfaces } from 'node:os'
 import { isIPv4, isIPv6 } from '@chainsafe/is-ip'
 import { TypedEventEmitter } from '@libp2p/interface'
-import { multiaddr, protocols } from '@multiformats/multiaddr'
-import { IP4 } from '@multiformats/multiaddr-matcher'
+import { multiaddr, protocols, fromStringTuples } from '@multiformats/multiaddr'
+import { IP4, WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { Crypto } from '@peculiar/webcrypto'
 import getPort from 'get-port'
 import pWaitFor from 'p-wait-for'
@@ -22,6 +22,8 @@ const crypto = new Crypto()
  * The time to wait, in milliseconds, for the data channel handshake to complete
  */
 const HANDSHAKE_TIMEOUT_MS = 10_000
+const CODEC_WEBRTC_DIRECT = 0x0118
+const CODEC_CERTHASH = 0x01d2
 
 export interface WebRTCDirectListenerComponents {
   peerId: PeerId
@@ -47,8 +49,15 @@ const UDP_PROTOCOL = protocols('udp')
 const IP4_PROTOCOL = protocols('ip4')
 const IP6_PROTOCOL = protocols('ip6')
 
+interface UDPMuxServer {
+  server: Promise<StunServer>
+  isIPv4: boolean
+  isIPv6: boolean
+  port: number
+}
+
 export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> implements Listener {
-  private server?: StunServer
+  private readonly servers: UDPMuxServer[]
   private readonly multiaddrs: Multiaddr[]
   private certificate?: TransportCertificate
   private readonly connections: Map<string, DirectRTCPeerConnection>
@@ -63,6 +72,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     this.init = init
     this.components = components
     this.multiaddrs = []
+    this.servers = []
     this.connections = new Map()
     this.log = components.logger.forComponent('libp2p:webrtc-direct:listener')
     this.certificate = init.certificates?.[0]
@@ -89,7 +99,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     if (host == null) {
       throw new Error('IP4/6 host must be specified in webrtc-direct mulitaddr')
     }
-    let port = parseInt(parts
+    const port = parseInt(parts
       .filter(([code, value]) => code === UDP_PROTOCOL.code)
       .pop()?.[1] ?? '')
 
@@ -97,41 +107,73 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       throw new Error('UDP port must be specified in webrtc-direct mulitaddr')
     }
 
-    if (port === 0 && this.init.useLibjuice !== false) {
-      // libjuice doesn't map 0 to a random free port so we have to do it
-      // ourselves
-      port = await getPort()
-    }
-
-    this.server = await stunListener(host, port, this.log, (ufrag, remoteHost, remotePort) => {
-      this.incomingConnection(ufrag, remoteHost, remotePort)
-        .catch(err => {
-          this.log.error('error processing incoming STUN request', err)
-        })
-    })
-
-    let certificate = this.certificate
-
-    if (certificate == null) {
-      const keyPair = await crypto.subtle.generateKey({
-        name: 'ECDSA',
-        namedCurve: 'P-256'
-      }, true, ['sign', 'verify'])
-
-      certificate = this.certificate = await generateTransportCertificate(keyPair, {
-        days: 365
-      })
+    // have to do this before any async work happens so starting two listeners
+    // for the same port concurrently (e.g. ipv4/ipv6 both port 0) results in a
+    // single mux listener. This is necessary because libjuice binds to all
+    // interfaces for a given port so we we need to key on just the port number
+    // not the host + the port number
+    let existingServer = this.servers.find(s => s.port === port)
+
+    // if the server has not been started yet, or the port is a wildcard port
+    // and there is already a wildcard port for this address family, start a new
+    // UDP mux server
+    const wildcardPorts = port === 0 && existingServer?.port === 0
+    const sameAddressFamily = (existingServer?.isIPv4 === true && isIPv4(host)) || (existingServer?.isIPv6 === true && isIPv6(host))
+
+    if (existingServer == null || (wildcardPorts && sameAddressFamily)) {
+      existingServer = this.startUDPMuxServer(host, port)
+      this.servers.push(existingServer)
     }
 
-    const address = this.server.address()
+    const server = await existingServer.server
+    const address = server.address()
 
-    getNetworkAddresses(address.address, address.port, ipVersion).forEach((ma) => {
-      this.multiaddrs.push(multiaddr(`${ma}/webrtc-direct/certhash/${certificate.certhash}`))
+    getNetworkAddresses(host, address.port, ipVersion).forEach((ma) => {
+      this.multiaddrs.push(multiaddr(`${ma}/webrtc-direct/certhash/${this.certificate?.certhash}`))
     })
 
     this.safeDispatchEvent('listening')
   }
 
+  private startUDPMuxServer (host: string, port: number): UDPMuxServer {
+    return {
+      port,
+      isIPv4: isIPv4(host),
+      isIPv6: isIPv6(host),
+      server: Promise.resolve()
+        .then(async (): Promise<StunServer> => {
+          if (port === 0) {
+            // libjuice doesn't map 0 to a random free port so we have to do it
+            // ourselves
+            port = await getPort()
+          }
+
+          // ensure we have a certificate
+          if (this.certificate == null) {
+            const keyPair = await crypto.subtle.generateKey({
+              name: 'ECDSA',
+              namedCurve: 'P-256'
+            }, true, ['sign', 'verify'])
+
+            const certificate = await generateTransportCertificate(keyPair, {
+              days: 365 * 10
+            })
+
+            if (this.certificate == null) {
+              this.certificate = certificate
+            }
+          }
+
+          return stunListener(host, port, this.log, (ufrag, remoteHost, remotePort) => {
+            this.incomingConnection(ufrag, remoteHost, remotePort)
+              .catch(err => {
+                this.log.error('error processing incoming STUN request', err)
+              })
+          })
+        })
+    }
+  }
+
   private async incomingConnection (ufrag: string, remoteHost: string, remotePort: number): Promise<void> {
     const key = `${remoteHost}:${remotePort}:${ufrag}`
     let peerConnection = this.connections.get(key)
@@ -184,12 +226,46 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     return this.multiaddrs
   }
 
+  updateAnnounceAddrs (multiaddrs: Multiaddr[]): void {
+    for (let i = 0; i < multiaddrs.length; i++) {
+      let ma = multiaddrs[i]
+
+      if (!WebRTCDirect.exactMatch(ma)) {
+        continue
+      }
+
+      // add the certhash if it is missing
+      const tuples = ma.stringTuples()
+
+      for (let j = 0; j < tuples.length; j++) {
+        if (tuples[j][0] !== CODEC_WEBRTC_DIRECT) {
+          continue
+        }
+
+        const certhashIndex = j + 1
+
+        if (tuples[certhashIndex] == null || tuples[certhashIndex][0] !== CODEC_CERTHASH) {
+          tuples.splice(certhashIndex, 0, [CODEC_CERTHASH, this.certificate?.certhash])
+
+          ma = fromStringTuples(tuples)
+          multiaddrs[i] = ma
+        }
+      }
+    }
+  }
+
   async close (): Promise<void> {
     for (const connection of this.connections.values()) {
       connection.close()
     }
 
-    await this.server?.close()
+    // stop all UDP mux listeners
+    await Promise.all(
+      this.servers.map(async p => {
+        const server = await p.server
+        await server.close()
+      })
+    )
 
     // RTCPeerConnections will be removed from the connections map when their
     // connection state changes to 'closed'/'disconnected'/'failed
@@ -202,7 +278,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
 }
 
 function getNetworkAddresses (host: string, port: number, version: 4 | 6): string[] {
-  if (host === '0.0.0.0' || host === '::1') {
+  if (host === '0.0.0.0' || host === '::') {
     // return all ip4 interfaces
     return Object.entries(networkInterfaces())
       .flatMap(([_, addresses]) => addresses)