@libp2p/webrtc 3.2.1 → 3.2.2-62a56b54

package/src/index.ts

@@ -3,6 +3,40 @@ import { WebRTCDirectTransport, type WebRTCTransportDirectInit, type WebRTCDirec
 import type { WebRTCTransportComponents, WebRTCTransportInit } from './private-to-private/transport.js'
 import type { Transport } from '@libp2p/interface/transport'
 
+export interface DataChannelOptions {
+  /**
+   * The maximum message size sendable over the channel in bytes (default 16KB)
+   */
+  maxMessageSize?: number
+
+  /**
+   * If the channel's `bufferedAmount` grows over this amount in bytes, wait
+   * for it to drain before sending more data (default: 16MB)
+   */
+  maxBufferedAmount?: number
+
+  /**
+   * When `bufferedAmount` is above `maxBufferedAmount`, we pause sending until
+   * the `bufferedAmountLow` event fires - this controls how long we wait for
+   * that event in ms (default: 30s)
+   */
+  bufferedAmountLowEventTimeout?: number
+
+  /**
+   * When closing a stream, we wait for `bufferedAmount` to become 0 before
+   * closing the underlying RTCDataChannel - this controls how long we wait
+   * in ms (default: 30s)
+   */
+  drainTimeout?: number
+
+  /**
+   * When closing a stream we first send a FIN flag to the remote and wait
+   * for a FIN_ACK reply before closing the underlying RTCDataChannel - this
+   * controls how long we wait for the acknowledgement in ms (default: 5s)
+   */
+  closeTimeout?: number
+}
+
 /**
  * @param {WebRTCTransportDirectInit} init - WebRTC direct transport configuration
  * @param init.dataChannel - DataChannel configurations

package/src/maconn.ts

@@ -5,7 +5,7 @@ import type { CounterGroup } from '@libp2p/interface/metrics'
 import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
 
-const log = logger('libp2p:webrtc:connection')
+const log = logger('libp2p:webrtc:maconn')
 
 interface WebRTCMultiaddrConnectionInit {
   /**
@@ -65,8 +65,13 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
     this.timeline = init.timeline
     this.peerConnection = init.peerConnection
 
+    const initialState = this.peerConnection.connectionState
+
     this.peerConnection.onconnectionstatechange = () => {
-      if (this.peerConnection.connectionState === 'closed' || this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed') {
+      log.trace('peer connection state change', this.peerConnection.connectionState, 'initial state', initialState)
+
+      if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
+        // nothing else to do but close the connection
         this.timeline.close = Date.now()
       }
     }

package/src/muxer.ts

@@ -1,6 +1,7 @@
+import { logger } from '@libp2p/logger'
 import { createStream } from './stream.js'
-import { nopSink, nopSource } from './util.js'
-import type { DataChannelOpts } from './stream.js'
+import { drainAndClose, nopSink, nopSource } from './util.js'
+import type { DataChannelOptions } from './index.js'
 import type { Stream } from '@libp2p/interface/connection'
 import type { CounterGroup } from '@libp2p/interface/metrics'
 import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface/stream-muxer'
@@ -8,6 +9,8 @@ import type { AbortOptions } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
+const log = logger('libp2p:webrtc:muxer')
+
 const PROTOCOL = '/webrtc'
 
 export interface DataChannelMuxerFactoryInit {
@@ -17,19 +20,16 @@ export interface DataChannelMuxerFactoryInit {
   peerConnection: RTCPeerConnection
 
   /**
-   * Optional metrics for this data channel muxer
+   * The protocol to use
    */
-  metrics?: CounterGroup
+  protocol?: string
 
   /**
-   * Data channel options
+   * Optional metrics for this data channel muxer
    */
-  dataChannelOptions?: Partial<DataChannelOpts>
+  metrics?: CounterGroup
 
-  /**
-   * The protocol to use
-   */
-  protocol?: string
+  dataChannelOptions?: DataChannelOptions
 }
 
 export class DataChannelMuxerFactory implements StreamMuxerFactory {
@@ -41,23 +41,23 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
   private readonly peerConnection: RTCPeerConnection
   private streamBuffer: Stream[] = []
   private readonly metrics?: CounterGroup
-  private readonly dataChannelOptions?: Partial<DataChannelOpts>
+  private readonly dataChannelOptions?: DataChannelOptions
 
   constructor (init: DataChannelMuxerFactoryInit) {
     this.peerConnection = init.peerConnection
     this.metrics = init.metrics
     this.protocol = init.protocol ?? PROTOCOL
-    this.dataChannelOptions = init.dataChannelOptions
+    this.dataChannelOptions = init.dataChannelOptions ?? {}
 
     // store any datachannels opened before upgrade has been completed
     this.peerConnection.ondatachannel = ({ channel }) => {
       const stream = createStream({
         channel,
         direction: 'inbound',
-        dataChannelOptions: init.dataChannelOptions,
         onEnd: () => {
           this.streamBuffer = this.streamBuffer.filter(s => s.id !== stream.id)
-        }
+        },
+        ...this.dataChannelOptions
       })
       this.streamBuffer.push(stream)
     }
@@ -90,34 +90,15 @@ export class DataChannelMuxer implements StreamMuxer {
   public protocol: string
 
   private readonly peerConnection: RTCPeerConnection
-  private readonly dataChannelOptions?: DataChannelOpts
+  private readonly dataChannelOptions: DataChannelOptions
   private readonly metrics?: CounterGroup
 
-  /**
-   * Gracefully close all tracked streams and stop the muxer
-   */
-  close: (options?: AbortOptions) => Promise<void> = async () => { }
-
-  /**
-   * Abort all tracked streams and stop the muxer
-   */
-  abort: (err: Error) => void = () => { }
-
-  /**
-   * The stream source, a no-op as the transport natively supports multiplexing
-   */
-  source: AsyncGenerator<Uint8Array, any, unknown> = nopSource()
-
-  /**
-   * The stream destination, a no-op as the transport natively supports multiplexing
-   */
-  sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>> = nopSink
-
   constructor (readonly init: DataChannelMuxerInit) {
     this.streams = init.streams
     this.peerConnection = init.peerConnection
     this.protocol = init.protocol ?? PROTOCOL
     this.metrics = init.metrics
+    this.dataChannelOptions = init.dataChannelOptions ?? {}
 
     /**
      * Fired when a data channel has been added to the connection has been
@@ -129,19 +110,19 @@ export class DataChannelMuxer implements StreamMuxer {
       const stream = createStream({
         channel,
         direction: 'inbound',
-        dataChannelOptions: this.dataChannelOptions,
         onEnd: () => {
+          log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
+          drainAndClose(channel, `inbound ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout)
           this.streams = this.streams.filter(s => s.id !== stream.id)
           this.metrics?.increment({ stream_end: true })
           init?.onStreamEnd?.(stream)
-        }
+        },
+        ...this.dataChannelOptions
       })
 
       this.streams.push(stream)
-      if ((init?.onIncomingStream) != null) {
-        this.metrics?.increment({ incoming_stream: true })
-        init.onIncomingStream(stream)
-      }
+      this.metrics?.increment({ incoming_stream: true })
+      init?.onIncomingStream?.(stream)
     }
 
     const onIncomingStream = init?.onIncomingStream
@@ -150,19 +131,52 @@ export class DataChannelMuxer implements StreamMuxer {
     }
   }
 
+  /**
+   * Gracefully close all tracked streams and stop the muxer
+   */
+  async close (options?: AbortOptions): Promise<void> {
+    try {
+      await Promise.all(
+        this.streams.map(async stream => stream.close(options))
+      )
+    } catch (err: any) {
+      this.abort(err)
+    }
+  }
+
+  /**
+   * Abort all tracked streams and stop the muxer
+   */
+  abort (err: Error): void {
+    for (const stream of this.streams) {
+      stream.abort(err)
+    }
+  }
+
+  /**
+   * The stream source, a no-op as the transport natively supports multiplexing
+   */
+  source: AsyncGenerator<Uint8Array, any, unknown> = nopSource()
+
+  /**
+   * The stream destination, a no-op as the transport natively supports multiplexing
+   */
+  sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>> = nopSink
+
   newStream (): Stream {
     // The spec says the label SHOULD be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
     const channel = this.peerConnection.createDataChannel('')
     const stream = createStream({
       channel,
       direction: 'outbound',
-      dataChannelOptions: this.dataChannelOptions,
       onEnd: () => {
-        channel.close() // Stream initiator is responsible for closing the channel
+        log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
+        drainAndClose(channel, `outbound ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout)
         this.streams = this.streams.filter(s => s.id !== stream.id)
         this.metrics?.increment({ stream_end: true })
         this.init?.onStreamEnd?.(stream)
-      }
+      },
+      ...this.dataChannelOptions
     })
     this.streams.push(stream)
     this.metrics?.increment({ outgoing_stream: true })

package/src/pb/message.proto

@@ -2,7 +2,8 @@ syntax = "proto3";
 
 message Message {
   enum Flag {
-    // The sender will no longer send messages on the stream.
+    // The sender will no longer send messages on the stream. The recipient
+    // should send a FIN_ACK back to the sender.
     FIN = 0;
 
     // The sender will no longer read messages on the stream. Incoming data is
@@ -12,6 +13,10 @@ message Message {
     // The sender abruptly terminates the sending part of the stream. The
     // receiver can discard any data that it already received on that stream.
     RESET = 2;
+
+    // The sender previously received a FIN.
+    // Workaround for https://bugs.chromium.org/p/chromium/issues/detail?id=1484907
+    FIN_ACK = 3;
   }
 
   optional Flag flag = 1;

package/src/pb/message.ts

@@ -17,13 +17,15 @@ export namespace Message {
   export enum Flag {
     FIN = 'FIN',
     STOP_SENDING = 'STOP_SENDING',
-    RESET = 'RESET'
+    RESET = 'RESET',
+    FIN_ACK = 'FIN_ACK'
   }
 
   enum __FlagValues {
     FIN = 0,
     STOP_SENDING = 1,
-    RESET = 2
+    RESET = 2,
+    FIN_ACK = 3
   }
 
   export namespace Flag {

package/src/private-to-private/initiate-connection.ts

@@ -0,0 +1,191 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { logger } from '@libp2p/logger'
+import { peerIdFromString } from '@libp2p/peer-id'
+import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
+import { pbStream } from 'it-protobuf-stream'
+import pDefer, { type DeferredPromise } from 'p-defer'
+import { type RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
+import { Message } from './pb/message.js'
+import { SIGNALING_PROTO_ID, splitAddr, type WebRTCTransportMetrics } from './transport.js'
+import { parseRemoteAddress, readCandidatesUntilConnected, resolveOnConnected } from './util.js'
+import type { DataChannelOptions } from '../index.js'
+import type { Connection } from '@libp2p/interface/connection'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
+
+const log = logger('libp2p:webrtc:initiate-connection')
+
+export interface IncomingStreamOpts extends IncomingStreamData {
+  rtcConfiguration?: RTCConfiguration
+  dataChannelOptions?: Partial<DataChannelOptions>
+  signal: AbortSignal
+}
+
+export interface ConnectOptions {
+  peerConnection: RTCPeerConnection
+  multiaddr: Multiaddr
+  connectionManager: ConnectionManager
+  transportManager: TransportManager
+  dataChannelOptions?: Partial<DataChannelOptions>
+  signal?: AbortSignal
+  metrics?: WebRTCTransportMetrics
+}
+
+export async function initiateConnection ({ peerConnection, signal, metrics, multiaddr: ma, connectionManager, transportManager }: ConnectOptions): Promise<{ remoteAddress: Multiaddr }> {
+  const { baseAddr, peerId } = splitAddr(ma)
+
+  metrics?.dialerEvents.increment({ open: true })
+
+  log.trace('dialing base address: %a', baseAddr)
+
+  const relayPeer = baseAddr.getPeerId()
+
+  if (relayPeer == null) {
+    throw new CodeError('Relay peer was missing', 'ERR_INVALID_ADDRESS')
+  }
+
+  const connections = connectionManager.getConnections(peerIdFromString(relayPeer))
+  let connection: Connection
+  let shouldCloseConnection = false
+
+  if (connections.length === 0) {
+    // use the transport manager to open a connection. Initiating a WebRTC
+    // connection takes place in the context of a dial - if we use the
+    // connection manager instead we can end up joining our own dial context
+    connection = await transportManager.dial(baseAddr, {
+      signal
+    })
+    // this connection is unmanaged by the connection manager so we should
+    // close it when we are done
+    shouldCloseConnection = true
+  } else {
+    connection = connections[0]
+  }
+
+  try {
+    const stream = await connection.newStream(SIGNALING_PROTO_ID, {
+      signal,
+      runOnTransientConnection: true
+    })
+
+    const messageStream = pbStream(stream).pb(Message)
+    const connectedPromise: DeferredPromise<void> = pDefer()
+    const sdpAbortedListener = (): void => {
+      connectedPromise.reject(new CodeError('SDP handshake aborted', 'ERR_SDP_HANDSHAKE_ABORTED'))
+    }
+
+    try {
+      resolveOnConnected(peerConnection, connectedPromise)
+
+      // reject the connectedPromise if the signal aborts
+      signal?.addEventListener('abort', sdpAbortedListener)
+
+      // we create the channel so that the RTCPeerConnection has a component for
+      // which to collect candidates. The label is not relevant to connection
+      // initiation but can be useful for debugging
+      const channel = peerConnection.createDataChannel('init')
+
+      // setup callback to write ICE candidates to the remote peer
+      peerConnection.onicecandidate = ({ candidate }) => {
+        // a null candidate means end-of-candidates, an empty string candidate
+        // means end-of-candidates for this generation, otherwise this should
+        // be a valid candidate object
+        // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+        const data = JSON.stringify(candidate?.toJSON() ?? null)
+
+        log.trace('initiator sending ICE candidate %s', data)
+
+        void messageStream.write({
+          type: Message.Type.ICE_CANDIDATE,
+          data
+        }, {
+          signal
+        })
+          .catch(err => {
+            log.error('error sending ICE candidate', err)
+          })
+      }
+      peerConnection.onicecandidateerror = (event) => {
+        log('initiator ICE candidate error', event)
+      }
+
+      // create an offer
+      const offerSdp = await peerConnection.createOffer()
+
+      log.trace('initiator send SDP offer %s', offerSdp.sdp)
+
+      // write the offer to the stream
+      await messageStream.write({ type: Message.Type.SDP_OFFER, data: offerSdp.sdp }, {
+        signal
+      })
+
+      // set offer as local description
+      await peerConnection.setLocalDescription(offerSdp).catch(err => {
+        log.error('could not execute setLocalDescription', err)
+        throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+      })
+
+      // read answer
+      const answerMessage = await messageStream.read({
+        signal
+      })
+
+      if (answerMessage.type !== Message.Type.SDP_ANSWER) {
+        throw new CodeError('remote should send an SDP answer', 'ERR_SDP_HANDSHAKE_FAILED')
+      }
+
+      log.trace('initiator receive SDP answer %s', answerMessage.data)
+
+      const answerSdp = new RTCSessionDescription({ type: 'answer', sdp: answerMessage.data })
+      await peerConnection.setRemoteDescription(answerSdp).catch(err => {
+        log.error('could not execute setRemoteDescription', err)
+        throw new CodeError('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+      })
+
+      log.trace('initiator read candidates until connected')
+
+      await readCandidatesUntilConnected(connectedPromise, peerConnection, messageStream, {
+        direction: 'initiator',
+        signal
+      })
+
+      log.trace('initiator connected, closing init channel')
+      channel.close()
+
+      log.trace('initiator closing signalling stream')
+      await messageStream.unwrap().unwrap().close({
+        signal
+      })
+
+      const remoteAddress = parseRemoteAddress(peerConnection.currentRemoteDescription?.sdp ?? '')
+
+      log.trace('initiator connected to remote address %s', remoteAddress)
+
+      return {
+        remoteAddress: multiaddr(remoteAddress).encapsulate(`/p2p/${peerId.toString()}`)
+      }
+    } catch (err: any) {
+      peerConnection.close()
+      stream.abort(err)
+      throw err
+    } finally {
+      // remove event listeners
+      signal?.removeEventListener('abort', sdpAbortedListener)
+      peerConnection.onicecandidate = null
+      peerConnection.onicecandidateerror = null
+    }
+  } finally {
+    // if we had to open a connection to perform the SDP handshake
+    // close it because it's not tracked by the connection manager
+    if (shouldCloseConnection) {
+      try {
+        await connection.close({
+          signal
+        })
+      } catch (err: any) {
+        connection.abort(err)
+      }
+    }
+  }
+}

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

@@ -5,20 +5,27 @@ import type { ListenerEvents, Listener } from '@libp2p/interface/transport'
 import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-export interface ListenerOptions {
+export interface WebRTCPeerListenerComponents {
   peerId: PeerId
   transportManager: TransportManager
 }
 
+export interface WebRTCPeerListenerInit {
+  shutdownController: AbortController
+}
+
 export class WebRTCPeerListener extends EventEmitter<ListenerEvents> implements Listener {
   private readonly peerId: PeerId
   private readonly transportManager: TransportManager
+  private readonly shutdownController: AbortController
 
-  constructor (opts: ListenerOptions) {
+  constructor (components: WebRTCPeerListenerComponents, init: WebRTCPeerListenerInit) {
     super()
 
-    this.peerId = opts.peerId
-    this.transportManager = opts.transportManager
+    this.peerId = components.peerId
+    this.transportManager = components.transportManager
+
+    this.shutdownController = init.shutdownController
   }
 
   async listen (): Promise<void> {
@@ -39,6 +46,7 @@ export class WebRTCPeerListener extends EventEmitter<ListenerEvents> implements
   }
 
   async close (): Promise<void> {
+    this.shutdownController.abort()
     this.safeDispatchEvent('close', {})
   }
 }

package/src/private-to-private/signaling-stream-handler.ts

@@ -0,0 +1,129 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { logger } from '@libp2p/logger'
+import { pbStream } from 'it-protobuf-stream'
+import pDefer, { type DeferredPromise } from 'p-defer'
+import { type RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
+import { Message } from './pb/message.js'
+import { parseRemoteAddress, readCandidatesUntilConnected, resolveOnConnected } from './util.js'
+import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
+
+const log = logger('libp2p:webrtc:signaling-stream-handler')
+
+export interface IncomingStreamOpts extends IncomingStreamData {
+  peerConnection: RTCPeerConnection
+  signal: AbortSignal
+}
+
+export async function handleIncomingStream ({ peerConnection, stream, signal, connection }: IncomingStreamOpts): Promise<{ remoteAddress: string }> {
+  log.trace('new inbound signaling stream')
+
+  const messageStream = pbStream(stream).pb(Message)
+
+  try {
+    const connectedPromise: DeferredPromise<void> = pDefer()
+    const answerSentPromise: DeferredPromise<void> = pDefer()
+
+    signal.onabort = () => {
+      connectedPromise.reject(new CodeError('Timed out while trying to connect', 'ERR_TIMEOUT'))
+    }
+
+    // candidate callbacks
+    peerConnection.onicecandidate = ({ candidate }) => {
+      answerSentPromise.promise.then(
+        async () => {
+          // a null candidate means end-of-candidates, an empty string candidate
+          // means end-of-candidates for this generation, otherwise this should
+          // be a valid candidate object
+          // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+          const data = JSON.stringify(candidate?.toJSON() ?? null)
+
+          log.trace('recipient sending ICE candidate %s', data)
+
+          await messageStream.write({
+            type: Message.Type.ICE_CANDIDATE,
+            data
+          }, {
+            signal
+          })
+        },
+        (err) => {
+          log.error('cannot set candidate since sending answer failed', err)
+          connectedPromise.reject(err)
+        }
+      )
+    }
+
+    resolveOnConnected(peerConnection, connectedPromise)
+
+    // read an SDP offer
+    const pbOffer = await messageStream.read({
+      signal
+    })
+
+    if (pbOffer.type !== Message.Type.SDP_OFFER) {
+      throw new CodeError(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `, 'ERR_SDP_HANDSHAKE_FAILED')
+    }
+
+    log.trace('recipient receive SDP offer %s', pbOffer.data)
+
+    const offer = new RTCSessionDescription({
+      type: 'offer',
+      sdp: pbOffer.data
+    })
+
+    await peerConnection.setRemoteDescription(offer).catch(err => {
+      log.error('could not execute setRemoteDescription', err)
+      throw new CodeError('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+    })
+
+    // create and write an SDP answer
+    const answer = await peerConnection.createAnswer().catch(err => {
+      log.error('could not execute createAnswer', err)
+      answerSentPromise.reject(err)
+      throw new CodeError('Failed to create answer', 'ERR_SDP_HANDSHAKE_FAILED')
+    })
+
+    log.trace('recipient send SDP answer %s', answer.sdp)
+
+    // write the answer to the remote
+    await messageStream.write({ type: Message.Type.SDP_ANSWER, data: answer.sdp }, {
+      signal
+    })
+
+    await peerConnection.setLocalDescription(answer).catch(err => {
+      log.error('could not execute setLocalDescription', err)
+      answerSentPromise.reject(err)
+      throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+    })
+
+    answerSentPromise.resolve()
+
+    log.trace('recipient read candidates until connected')
+
+    // wait until candidates are connected
+    await readCandidatesUntilConnected(connectedPromise, peerConnection, messageStream, {
+      direction: 'recipient',
+      signal
+    })
+
+    log.trace('recipient connected, closing signaling stream')
+    await messageStream.unwrap().unwrap().close({
+      signal
+    })
+  } catch (err: any) {
+    if (peerConnection.connectionState !== 'connected') {
+      log.error('error while handling signaling stream from peer %a', connection.remoteAddr, err)
+
+      peerConnection.close()
+      throw err
+    } else {
+      log('error while handling signaling stream from peer %a, ignoring as the RTCPeerConnection is already connected', connection.remoteAddr, err)
+    }
+  }
+
+  const remoteAddress = parseRemoteAddress(peerConnection.currentRemoteDescription?.sdp ?? '')
+
+  log.trace('recipient connected to remote address %s', remoteAddress)
+
+  return { remoteAddress }
+}