@libp2p/webrtc 5.1.1 → 5.2.0-2b49a5f74

package/src/index.ts

@@ -33,7 +33,6 @@
  * import { identify } from '@libp2p/identify'
  * import { webRTC } from '@libp2p/webrtc'
  * import { webSockets } from '@libp2p/websockets'
- * import * as filters from '@libp2p/websockets/filters'
  * import { WebRTC } from '@multiformats/multiaddr-matcher'
  * import delay from 'delay'
  * import { pipe } from 'it-pipe'
@@ -47,10 +46,13 @@
  *   listen: ['/ip4/127.0.0.1/tcp/0/ws']
  *   },
  *   transports: [
- *     webSockets({filter: filters.all})
+ *     webSockets()
  *   ],
  *   connectionEncrypters: [noise()],
  *   streamMuxers: [yamux()],
+ *   connectionGater: {
+ *     denyDialMultiaddr: () => false
+ *   },
  *   services: {
  *     identify: identify(),
  *     relay: circuitRelayServer()
@@ -68,12 +70,15 @@
  *     ]
  *   },
  *   transports: [
- *     webSockets({filter: filters.all}),
+ *     webSockets(),
  *     webRTC(),
  *     circuitRelayTransport()
  *   ],
  *   connectionEncrypters: [noise()],
  *   streamMuxers: [yamux()],
+ *   connectionGater: {
+ *     denyDialMultiaddr: () => false
+ *   },
  *   services: {
  *     identify: identify(),
  *     echo: echo()
@@ -105,12 +110,15 @@
  * // direct WebRTC connection
  * const dialer = await createLibp2p({
  *   transports: [
- *     webSockets({filter: filters.all}),
+ *     webSockets(),
  *     webRTC(),
  *     circuitRelayTransport()
  *   ],
  *   connectionEncrypters: [noise()],
  *   streamMuxers: [yamux()],
+ *   connectionGater: {
+ *     denyDialMultiaddr: () => false
+ *   },
  *   services: {
  *     identify: identify(),
  *     echo: echo()
@@ -139,9 +147,22 @@
  *
  * @example WebRTC Direct
  *
- * At the time of writing WebRTC Direct is dial-only in browsers and unsupported in Node.js.
+ * WebRTC Direct allows a client to establish a WebRTC connection to a server
+ * without using a relay to first exchange SDP messages.
+ *
+ * Instead the server listens on a public UDP port and embeds its certificate
+ * hash in the published multiaddr. It derives the client's SDP offer based on
+ * the incoming IP/port of STUN messages sent to this public port.
+ *
+ * The client derives the server's SDP answer based on the information in the
+ * multiaddr so no SDP handshake via a third party is required.
+ *
+ * Full details of the connection protocol can be found in the [WebRTC Direct spec](https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md).
+ *
+ * Browsers cannot listen on WebRTC Direct addresses since they cannot open
+ * ports, but they can dial all spec-compliant servers.
  *
- * The only implementation that supports a WebRTC Direct listener is go-libp2p and it's not yet enabled by default.
+ * Node.js/go and rust-libp2p can listen on and dial WebRTC Direct addresses.
  *
  * ```TypeScript
  * import { createLibp2p } from 'libp2p'

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

@@ -36,7 +36,7 @@ export class WebRTCPeerListener extends TypedEventEmitter<ListenerEvents> implem
   getAddrs (): Multiaddr[] {
     return this.transportManager
       .getListeners()
-      .filter(l => l !== this)
+      .filter(l => !(l instanceof WebRTCPeerListener))
       .map(l => l.getAddrs()
         .filter(ma => Circuit.exactMatch(ma))
         .map(ma => {
@@ -46,6 +46,10 @@ export class WebRTCPeerListener extends TypedEventEmitter<ListenerEvents> implem
       .flat()
   }
 
+  updateAnnounceAddrs (): void {
+
+  }
+
   async close (): Promise<void> {
     this.shutdownController.abort()
     queueMicrotask(() => {

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

@@ -22,6 +22,10 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     return []
   }
 
+  updateAnnounceAddrs (): void {
+
+  }
+
   async close (): Promise<void> {
 
   }

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 { InvalidPeerIdError, TypedEventEmitter } from '@libp2p/interface'
+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,18 @@ 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
+  owner: WebRTCDirectListener
+  peerId: PeerId
+}
+
+let UDP_MUX_LISTENERS: UDPMuxServer[] = []
+
 export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> implements Listener {
-  private server?: StunServer
   private readonly multiaddrs: Multiaddr[]
   private certificate?: TransportCertificate
   private readonly connections: Map<string, DirectRTCPeerConnection>
@@ -89,7 +101,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 +109,90 @@ 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()
+    // 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 = UDP_MUX_LISTENERS.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))
+    let createdMuxServer = false
+
+    if (existingServer == null || (wildcardPorts && sameAddressFamily)) {
+      this.log('starting UDP mux server on %s:%p', host, port)
+      existingServer = this.startUDPMuxServer(host, port)
+      UDP_MUX_LISTENERS.push(existingServer)
+      createdMuxServer = true
     }
 
-    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 (!existingServer.peerId.equals(this.components.peerId)) {
+      // this would have to be another in-process peer so we are likely in a
+      // testing environment
+      throw new InvalidPeerIdError(`Another peer is already performing UDP mux on ${host}:${existingServer.port}`)
+    }
 
-    if (certificate == null) {
-      const keyPair = await crypto.subtle.generateKey({
-        name: 'ECDSA',
-        namedCurve: 'P-256'
-      }, true, ['sign', 'verify'])
+    const server = await existingServer.server
+    const address = server.address()
 
-      certificate = this.certificate = await generateTransportCertificate(keyPair, {
-        days: 365
-      })
+    if (!createdMuxServer) {
+      this.log('reused existing UDP mux server on %s:%p', host, address.port)
     }
 
-    const address = this.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 {
+      peerId: this.components.peerId,
+      owner: this,
+      port,
+      isIPv4: isIPv4(host),
+      isIPv6: isIPv6(host),
+      server: Promise.resolve()
+        .then(async (): Promise<StunServer> => {
+          // ensure we have a certificate
+          if (this.certificate == null) {
+            this.log.trace('creating TLS certificate')
+            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
+            }
+          }
+
+          if (port === 0) {
+            // libjuice doesn't map 0 to a random free port so we have to do it
+            // ourselves
+            this.log.trace('searching for free port')
+            port = await getPort()
+          }
+
+          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 +245,51 @@ 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 our UDP mux listeners
+    await Promise.all(
+      UDP_MUX_LISTENERS
+        .filter(listener => listener.owner === this)
+        .map(async listener => {
+          const server = await listener.server
+          await server.close()
+        })
+    )
+
+    // remove our stopped UDP mux listeners
+    UDP_MUX_LISTENERS = UDP_MUX_LISTENERS.filter(listener => listener.owner !== this)
 
     // RTCPeerConnections will be removed from the connections map when their
     // connection state changes to 'closed'/'disconnected'/'failed
@@ -202,7 +302,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)

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  ".:DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  "TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  ".:TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  "WebRTCDirectTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCDirectTransportComponents.html",
-  "WebRTCTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportComponents.html",
-  "WebRTCTransportDirectInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportDirectInit.html",
-  "WebRTCTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportInit.html",
-  "webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  ".:webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  "webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html",
-  ".:webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html"
-}