@libp2p/webrtc 3.2.1 → 3.2.2-62a56b54

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

@@ -6,26 +6,36 @@ import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
 import { codes } from '../error.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
-import { cleanup } from '../webrtc/index.js'
-import { initiateConnection, handleIncomingStream } from './handler.js'
+import { DataChannelMuxerFactory } from '../muxer.js'
+import { cleanup, RTCPeerConnection } from '../webrtc/index.js'
+import { initiateConnection } from './initiate-connection.js'
 import { WebRTCPeerListener } from './listener.js'
-import type { DataChannelOpts } from '../stream.js'
+import { handleIncomingStream } from './signaling-stream-handler.js'
+import type { DataChannelOptions } from '../index.js'
 import type { Connection } from '@libp2p/interface/connection'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { CounterGroup, Metrics } from '@libp2p/interface/src/metrics/index.js'
 import type { Startable } from '@libp2p/interface/startable'
 import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
+import type { ConnectionManager } from '@libp2p/interface-internal/src/connection-manager/index.js'
 import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:webrtc:peer')
 
 const WEBRTC_TRANSPORT = '/webrtc'
 const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
-const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
+export const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
+const INBOUND_CONNECTION_TIMEOUT = 30 * 1000
 
 export interface WebRTCTransportInit {
   rtcConfiguration?: RTCConfiguration
-  dataChannel?: Partial<DataChannelOpts>
+  dataChannel?: DataChannelOptions
+
+  /**
+   * Inbound connections must complete the upgrade within this many ms
+   * (default: 30s)
+   */
+  inboundConnectionTimeout?: number
 }
 
 export interface WebRTCTransportComponents {
@@ -33,6 +43,7 @@ export interface WebRTCTransportComponents {
   registrar: Registrar
   upgrader: Upgrader
   transportManager: TransportManager
+  connectionManager: ConnectionManager
   metrics?: Metrics
 }
 
@@ -44,11 +55,14 @@ export interface WebRTCTransportMetrics {
 export class WebRTCTransport implements Transport, Startable {
   private _started = false
   private readonly metrics?: WebRTCTransportMetrics
+  private readonly shutdownController: AbortController
 
   constructor (
     private readonly components: WebRTCTransportComponents,
     private readonly init: WebRTCTransportInit = {}
   ) {
+    this.shutdownController = new AbortController()
+
     if (components.metrics != null) {
       this.metrics = {
         dialerEvents: components.metrics.registerCounterGroup('libp2p_webrtc_dialer_events_total', {
@@ -83,7 +97,9 @@ export class WebRTCTransport implements Transport, Startable {
   }
 
   createListener (options: CreateListenerOptions): Listener {
-    return new WebRTCPeerListener(this.components)
+    return new WebRTCPeerListener(this.components, {
+      shutdownController: this.shutdownController
+    })
   }
 
   readonly [Symbol.toStringTag] = '@libp2p/webrtc'
@@ -102,84 +118,96 @@ export class WebRTCTransport implements Transport, Startable {
    * <relay address>/p2p/<relay-peer>/p2p-circuit/webrtc/p2p/<destination-peer>
   */
   async dial (ma: Multiaddr, options: DialOptions): Promise<Connection> {
-    log.trace('dialing address: ', ma)
-    const { baseAddr, peerId } = splitAddr(ma)
+    log.trace('dialing address: %a', ma)
 
-    if (options.signal == null) {
-      const controller = new AbortController()
-      options.signal = controller.signal
-    }
+    const peerConnection = new RTCPeerConnection(this.init.rtcConfiguration)
+    const muxerFactory = new DataChannelMuxerFactory({
+      peerConnection,
+      dataChannelOptions: this.init.dataChannel
+    })
 
-    this.metrics?.dialerEvents.increment({ open: true })
-    const connection = await this.components.transportManager.dial(baseAddr, options)
-    const signalingStream = await connection.newStream(SIGNALING_PROTO_ID, {
-      ...options,
-      runOnTransientConnection: true
+    const { remoteAddress } = await initiateConnection({
+      peerConnection,
+      multiaddr: ma,
+      dataChannelOptions: this.init.dataChannel,
+      signal: options.signal,
+      connectionManager: this.components.connectionManager,
+      transportManager: this.components.transportManager
     })
 
-    try {
-      const { pc, muxerFactory, remoteAddress } = await initiateConnection({
-        stream: signalingStream,
-        rtcConfiguration: this.init.rtcConfiguration,
-        dataChannelOptions: this.init.dataChannel,
-        signal: options.signal
-      })
+    const webRTCConn = new WebRTCMultiaddrConnection({
+      peerConnection,
+      timeline: { open: Date.now() },
+      remoteAddr: remoteAddress,
+      metrics: this.metrics?.dialerEvents
+    })
 
-      const result = await options.upgrader.upgradeOutbound(
-        new WebRTCMultiaddrConnection({
-          peerConnection: pc,
-          timeline: { open: Date.now() },
-          remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${peerId.toString()}`),
-          metrics: this.metrics?.dialerEvents
-        }),
-        {
-          skipProtection: true,
-          skipEncryption: true,
-          muxerFactory
-        }
-      )
-
-      // close the stream if SDP has been exchanged successfully
-      await signalingStream.close()
-      return result
-    } catch (err: any) {
-      this.metrics?.dialerEvents.increment({ error: true })
-      // reset the stream in case of any error
-      signalingStream.abort(err)
-      throw err
-    } finally {
-      // Close the signaling connection
-      await connection.close()
-    }
+    const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
+      skipProtection: true,
+      skipEncryption: true,
+      muxerFactory
+    })
+
+    // close the connection on shut down
+    this._closeOnShutdown(peerConnection, webRTCConn)
+
+    return connection
   }
 
   async _onProtocol ({ connection, stream }: IncomingStreamData): Promise<void> {
+    const signal = AbortSignal.timeout(this.init.inboundConnectionTimeout ?? INBOUND_CONNECTION_TIMEOUT)
+    const peerConnection = new RTCPeerConnection(this.init.rtcConfiguration)
+    const muxerFactory = new DataChannelMuxerFactory({ peerConnection, dataChannelOptions: this.init.dataChannel })
+
     try {
-      const { pc, muxerFactory, remoteAddress } = await handleIncomingStream({
-        rtcConfiguration: this.init.rtcConfiguration,
+      const { remoteAddress } = await handleIncomingStream({
+        peerConnection,
         connection,
         stream,
-        dataChannelOptions: this.init.dataChannel
+        signal
       })
 
-      await this.components.upgrader.upgradeInbound(new WebRTCMultiaddrConnection({
-        peerConnection: pc,
+      const webRTCConn = new WebRTCMultiaddrConnection({
+        peerConnection,
         timeline: { open: (new Date()).getTime() },
         remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${connection.remotePeer.toString()}`),
         metrics: this.metrics?.listenerEvents
-      }), {
+      })
+
+      // close the connection on shut down
+      this._closeOnShutdown(peerConnection, webRTCConn)
+
+      await this.components.upgrader.upgradeInbound(webRTCConn, {
         skipEncryption: true,
         skipProtection: true,
         muxerFactory
       })
+
+      // close the stream if SDP messages have been exchanged successfully
+      await stream.close({
+        signal
+      })
     } catch (err: any) {
       stream.abort(err)
       throw err
-    } finally {
-      // Close the signaling connection
-      await connection.close()
     }
   }
+
+  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: WebRTCMultiaddrConnection): void {
+    // close the connection on shut down
+    const shutDownListener = (): void => {
+      webRTCConn.close()
+        .catch(err => {
+          log.error('could not close WebRTCMultiaddrConnection', err)
+        })
+    }
+
+    this.shutdownController.signal.addEventListener('abort', shutDownListener)
+
+    pc.addEventListener('close', () => {
+      this.shutdownController.signal.removeEventListener('abort', shutDownListener)
+    })
+  }
 }
 
 export function splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId } {

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

@@ -1,49 +1,101 @@
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
+import { abortableSource } from 'abortable-iterator'
+import { anySignal } from 'any-signal'
+import * as lp from 'it-length-prefixed'
+import { AbortError, raceSignal } from 'race-signal'
 import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
+import type { Stream } from '@libp2p/interface/connection'
+import type { AbortOptions, MessageStream } from 'it-protobuf-stream'
 import type { DeferredPromise } from 'p-defer'
 
-interface MessageStream {
-  read: () => Promise<Message>
-  write: (d: Message) => void | Promise<void>
+const log = logger('libp2p:webrtc:peer:util')
+
+export interface ReadCandidatesOptions extends AbortOptions {
+  direction: string
 }
 
-const log = logger('libp2p:webrtc:peer:util')
+export const readCandidatesUntilConnected = async (connectedPromise: DeferredPromise<void>, pc: RTCPeerConnection, stream: MessageStream<Message, Stream>, options: ReadCandidatesOptions): Promise<void> => {
+  // if we connect, stop trying to read from the stream
+  const controller = new AbortController()
+  connectedPromise.promise.then(() => {
+    controller.abort()
+  }, () => {
+    controller.abort()
+  })
+
+  const signal = anySignal([
+    controller.signal,
+    options.signal
+  ])
+
+  const source = abortableSource(stream.unwrap().unwrap().source, signal, {
+    returnOnAbort: true
+  })
+
+  try {
+    // read candidates until we are connected or we reach the end of the stream
+    for await (const buf of lp.decode(source)) {
+      const message = Message.decode(buf)
 
-export const readCandidatesUntilConnected = async (connectedPromise: DeferredPromise<void>, pc: RTCPeerConnection, stream: MessageStream): Promise<void> => {
-  while (true) {
-    const readResult = await Promise.race([connectedPromise.promise, stream.read()])
-    // check if readResult is a message
-    if (readResult instanceof Object) {
-      const message = readResult
       if (message.type !== Message.Type.ICE_CANDIDATE) {
-        throw new Error('expected only ice candidates')
+        throw new CodeError('ICE candidate message expected', 'ERR_NOT_ICE_CANDIDATE')
       }
-      // end of candidates has been signalled
-      if (message.data == null || message.data === '') {
+
+      let candidateInit = JSON.parse(message.data ?? 'null')
+
+      if (candidateInit === '') {
+        log.trace('end-of-candidates for this generation received')
+        candidateInit = {
+          candidate: '',
+          sdpMid: '0',
+          sdpMLineIndex: 0
+        }
+      }
+
+      if (candidateInit === null) {
         log.trace('end-of-candidates received')
-        break
+        candidateInit = {
+          candidate: null,
+          sdpMid: '0',
+          sdpMLineIndex: 0
+        }
       }
 
-      log.trace('received new ICE candidate: %s', message.data)
+      // a null candidate means end-of-candidates
+      // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+      const candidate = new RTCIceCandidate(candidateInit)
+
+      log.trace('%s received new ICE candidate', options.direction, candidate)
+
       try {
-        await pc.addIceCandidate(new RTCIceCandidate(JSON.parse(message.data)))
+        await pc.addIceCandidate(candidate)
       } catch (err) {
-        log.error('bad candidate received: ', err)
-        throw new Error('bad candidate received')
+        log.error('%s bad candidate received', options.direction, err)
       }
-    } else {
-      // connected promise resolved
-      break
     }
+  } catch (err) {
+    log.error('%s error parsing ICE candidate', options.direction, err)
+  } finally {
+    signal.clear()
   }
-  await connectedPromise.promise
+
+  if (options.signal?.aborted === true) {
+    throw new AbortError('Aborted while reading ICE candidates', 'ERR_ICE_CANDIDATES_READ_ABORTED')
+  }
+
+  // read all available ICE candidates, wait for connection state change
+  await raceSignal(connectedPromise.promise, options.signal, {
+    errorMessage: 'Aborted before connected',
+    errorCode: 'ERR_ABORTED_BEFORE_CONNECTED'
+  })
 }
 
 export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
   pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
-    log.trace('receiver peerConnectionState state: ', pc.connectionState)
+    log.trace('receiver peerConnectionState state change: %s', pc.connectionState)
     switch (isFirefox ? pc.iceConnectionState : pc.connectionState) {
       case 'connected':
         promise.resolve()
@@ -51,10 +103,23 @@ export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredProm
       case 'failed':
       case 'disconnected':
       case 'closed':
-        promise.reject(new Error('RTCPeerConnection was closed'))
+        promise.reject(new CodeError('RTCPeerConnection was closed', 'ERR_CONNECTION_CLOSED_BEFORE_CONNECTED'))
         break
       default:
         break
     }
   }
 }
+
+export function parseRemoteAddress (sdp: string): string {
+  // 'a=candidate:1746876089 1 udp 2113937151 0614fbad-b...ocal 54882 typ host generation 0 network-cost 999'
+  const candidateLine = sdp.split('\r\n').filter(line => line.startsWith('a=candidate')).pop()
+  const candidateParts = candidateLine?.split(' ')
+
+  if (candidateLine == null || candidateParts == null || candidateParts.length < 5) {
+    log('could not parse remote address from', candidateLine)
+    return '/webrtc'
+  }
+
+  return `/dnsaddr/${candidateParts[4]}/${candidateParts[2].toLowerCase()}/${candidateParts[5]}/webrtc`
+}

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

@@ -16,7 +16,7 @@ import { RTCPeerConnection } from '../webrtc/index.js'
 import * as sdp from './sdp.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
-import type { DataChannelOpts } from '../stream.js'
+import type { DataChannelOptions } from '../index.js'
 import type { Connection } from '@libp2p/interface/connection'
 import type { CounterGroup, Metrics } from '@libp2p/interface/metrics'
 import type { PeerId } from '@libp2p/interface/peer-id'
@@ -56,7 +56,7 @@ export interface WebRTCMetrics {
 }
 
 export interface WebRTCTransportDirectInit {
-  dataChannel?: Partial<DataChannelOpts>
+  dataChannel?: DataChannelOptions
 }
 
 export class WebRTCDirectTransport implements Transport {
@@ -81,7 +81,7 @@ export class WebRTCDirectTransport implements Transport {
    */
   async dial (ma: Multiaddr, options: WebRTCDialOptions): Promise<Connection> {
     const rawConn = await this._connect(ma, options)
-    log(`dialing address - ${ma.toString()}`)
+    log('dialing address: %a', ma)
     return rawConn
   }
 
@@ -194,7 +194,7 @@ export class WebRTCDirectTransport implements Transport {
       // we pass in undefined for these parameters.
       const noise = Noise({ prologueBytes: fingerprintsPrologue })()
 
-      const wrappedChannel = createStream({ channel: handshakeDataChannel, direction: 'inbound', dataChannelOptions: this.init.dataChannel })
+      const wrappedChannel = createStream({ channel: handshakeDataChannel, direction: 'inbound', ...(this.init.dataChannel ?? {}) })
       const wrappedDuplex = {
         ...wrappedChannel,
         sink: wrappedChannel.sink.bind(wrappedChannel),