@libp2p/webrtc 3.2.11-9c67c5b3d → 3.2.11-adea7bbbf

package/src/muxer.ts

@@ -51,6 +51,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
   private readonly metrics?: CounterGroup
   private readonly dataChannelOptions?: DataChannelOptions
   private readonly components: DataChannelMuxerFactoryComponents
+  private readonly log: Logger
 
   constructor (components: DataChannelMuxerFactoryComponents, init: DataChannelMuxerFactoryInit) {
     this.components = components
@@ -58,9 +59,20 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
     this.metrics = init.metrics
     this.protocol = init.protocol ?? PROTOCOL
     this.dataChannelOptions = init.dataChannelOptions ?? {}
+    this.log = components.logger.forComponent('libp2p:webrtc:datachannelmuxerfactory')
 
     // store any datachannels opened before upgrade has been completed
     this.peerConnection.ondatachannel = ({ channel }) => {
+      this.log.trace('incoming early datachannel with channel id %d and label "%s"', channel.id)
+
+      // 'init' channel is only used during connection establishment
+      if (channel.label === 'init') {
+        this.log.trace('closing early init channel')
+        channel.close()
+
+        return
+      }
+
       // @ts-expect-error fields are set below
       const bufferedStream: BufferedStream = {}
 
@@ -136,10 +148,21 @@ export class DataChannelMuxer implements StreamMuxer {
      * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event}
      */
     this.peerConnection.ondatachannel = ({ channel }) => {
+      this.log.trace('incoming datachannel with channel id %d', channel.id)
+
+      // 'init' channel is only used during connection establishment
+      if (channel.label === 'init') {
+        this.log.trace('closing init channel')
+        channel.close()
+
+        return
+      }
+
       const stream = createStream({
         channel,
         direction: 'inbound',
         onEnd: () => {
+          this.log('incoming channel %s ended with state %s', channel.id, channel.readyState)
           this.#onStreamEnd(stream, channel)
         },
         logger: this.logger,
@@ -161,6 +184,7 @@ export class DataChannelMuxer implements StreamMuxer {
       queueMicrotask(() => {
         this.init.streams.forEach(bufferedStream => {
           bufferedStream.onEnd = () => {
+            this.log('incoming early channel %s ended with state %s', bufferedStream.channel.id, bufferedStream.channel.readyState)
             this.#onStreamEnd(bufferedStream.stream, bufferedStream.channel)
           }
 
@@ -220,10 +244,14 @@ export class DataChannelMuxer implements StreamMuxer {
   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('')
+
+    this.log.trace('opened outgoing datachannel with channel id %s', channel.id)
+
     const stream = createStream({
       channel,
       direction: 'outbound',
       onEnd: () => {
+        this.log('outgoing channel %s ended with state %s', channel.id, channel.readyState)
         this.#onStreamEnd(stream, channel)
       },
       logger: this.logger,

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

@@ -1,8 +1,6 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { abortableSource } from 'abortable-iterator'
+import { closeSource } from '@libp2p/utils/close-source'
 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'
@@ -29,41 +27,40 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
     options.signal
   ])
 
-  const source = abortableSource(stream.unwrap().unwrap().source, signal, {
-    returnOnAbort: true
-  })
+  const abortListener = (): void => {
+    closeSource(stream.unwrap().unwrap().source, options.log)
+  }
+
+  signal.addEventListener('abort', abortListener)
 
   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)
+    while (true) {
+      const message = await Promise.race([
+        connectedPromise.promise,
+        stream.read()
+      ])
+
+      // stream ended or we became connected
+      if (message == null) {
+        break
+      }
 
       if (message.type !== Message.Type.ICE_CANDIDATE) {
         throw new CodeError('ICE candidate message expected', 'ERR_NOT_ICE_CANDIDATE')
       }
 
-      let candidateInit = JSON.parse(message.data ?? 'null')
-
-      if (candidateInit === '') {
-        options.log.trace('end-of-candidates for this generation received')
-        candidateInit = {
-          candidate: '',
-          sdpMid: '0',
-          sdpMLineIndex: 0
-        }
-      }
+      const candidateInit = JSON.parse(message.data ?? 'null')
 
-      if (candidateInit === null) {
+      // an empty string means this generation of candidates is complete, a null
+      // candidate means candidate gathering has finished
+      // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+      if (candidateInit === '' || candidateInit === null) {
         options.log.trace('end-of-candidates received')
-        candidateInit = {
-          candidate: null,
-          sdpMid: '0',
-          sdpMLineIndex: 0
-        }
+
+        continue
       }
 
-      // a null candidate means end-of-candidates
-      // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
       const candidate = new RTCIceCandidate(candidateInit)
 
       options.log.trace('%s received new ICE candidate', options.direction, candidate)
@@ -71,24 +68,15 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
       try {
         await pc.addIceCandidate(candidate)
       } catch (err) {
-        options.log.error('%s bad candidate received', options.direction, err)
+        options.log.error('%s bad candidate received', options.direction, candidateInit, err)
       }
     }
   } catch (err) {
     options.log.error('%s error parsing ICE candidate', options.direction, err)
   } finally {
+    signal.removeEventListener('abort', abortListener)
     signal.clear()
   }
-
-  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 {

package/src/stream.ts

@@ -1,5 +1,5 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { AbstractStream, type AbstractStreamInit } from '@libp2p/interface/stream-muxer/stream'
+import { AbstractStream, type AbstractStreamInit } from '@libp2p/utils/abstract-stream'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { type Pushable, pushable } from 'it-pushable'
 import pDefer from 'p-defer'
@@ -57,6 +57,12 @@ export const MAX_MESSAGE_SIZE = 16 * 1024
  */
 export const FIN_ACK_TIMEOUT = 5000
 
+/**
+ * When sending data messages, if the channel is not in the "open" state, wait
+ * this long for the "open" event to fire.
+ */
+export const OPEN_TIMEOUT = 5000
+
 export class WebRTCStream extends AbstractStream {
   /**
    * The data channel used to send and receive data
@@ -69,8 +75,6 @@ export class WebRTCStream extends AbstractStream {
    */
   private readonly incomingData: Pushable<Uint8Array>
 
-  private messageQueue?: Uint8ArrayList
-
   private readonly maxBufferedAmount: number
 
   private readonly bufferedAmountLowEventTimeout: number
@@ -85,6 +89,7 @@ export class WebRTCStream extends AbstractStream {
    */
   private readonly receiveFinAck: DeferredPromise<void>
   private readonly finAckTimeout: number
+  private readonly openTimeout: number
 
   constructor (init: WebRTCStreamInit) {
     // override onEnd to send/receive FIN_ACK before closing the stream
@@ -122,17 +127,18 @@ export class WebRTCStream extends AbstractStream {
 
     this.channel = init.channel
     this.channel.binaryType = 'arraybuffer'
-    this.incomingData = pushable()
-    this.messageQueue = new Uint8ArrayList()
+    this.incomingData = pushable<Uint8Array>()
     this.bufferedAmountLowEventTimeout = init.bufferedAmountLowEventTimeout ?? BUFFERED_AMOUNT_LOW_TIMEOUT
     this.maxBufferedAmount = init.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT
     this.maxMessageSize = (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD - VARINT_LENGTH
     this.receiveFinAck = pDefer()
     this.finAckTimeout = init.closeTimeout ?? FIN_ACK_TIMEOUT
+    this.openTimeout = init.openTimeout ?? OPEN_TIMEOUT
 
     // set up initial state
     switch (this.channel.readyState) {
       case 'open':
+        this.timeline.open = new Date().getTime()
         break
 
       case 'closed':
@@ -153,19 +159,6 @@ export class WebRTCStream extends AbstractStream {
     // handle RTCDataChannel events
     this.channel.onopen = (_evt) => {
       this.timeline.open = new Date().getTime()
-
-      if (this.messageQueue != null && this.messageQueue.byteLength > 0) {
-        this.log.trace('dataChannel opened, sending queued messages', this.messageQueue.byteLength, this.channel.readyState)
-
-        // send any queued messages
-        this._sendMessage(this.messageQueue)
-          .catch(err => {
-            this.log.error('error sending queued messages', err)
-            this.abort(err)
-          })
-      }
-
-      this.messageQueue = undefined
     }
 
     this.channel.onclose = (_evt) => {
@@ -218,6 +211,7 @@ export class WebRTCStream extends AbstractStream {
   async _sendMessage (data: Uint8ArrayList, checkBuffer: boolean = true): Promise<void> {
     if (checkBuffer && this.channel.bufferedAmount > this.maxBufferedAmount) {
       try {
+        this.log('channel buffer is %d, wait for "bufferedamountlow" event', this.channel.bufferedAmount)
         await pEvent(this.channel, 'bufferedamountlow', { timeout: this.bufferedAmountLowEventTimeout })
       } catch (err: any) {
         if (err instanceof TimeoutError) {
@@ -232,22 +226,14 @@ export class WebRTCStream extends AbstractStream {
       throw new CodeError(`Invalid datachannel state - ${this.channel.readyState}`, 'ERR_INVALID_STATE')
     }
 
-    if (this.channel.readyState === 'open') {
-      // send message without copying data
-      for (const buf of data) {
-        this.channel.send(buf)
-      }
-    } else if (this.channel.readyState === 'connecting') {
-      // queue message for when we are open
-      if (this.messageQueue == null) {
-        this.messageQueue = new Uint8ArrayList()
-      }
-
-      this.messageQueue.append(data)
-    } else {
-      this.log.error('unknown datachannel state %s', this.channel.readyState)
-      throw new CodeError('Unknown datachannel state', 'ERR_INVALID_STATE')
+    if (this.channel.readyState !== 'open') {
+      this.log('channel state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
+      await pEvent(this.channel, 'open', { timeout: this.openTimeout })
+      this.log('channel state is now "%s", sending data', this.channel.readyState)
     }
+
+    // send message without copying data
+    this.channel.send(data.subarray())
   }
 
   async sendData (data: Uint8ArrayList): Promise<void> {
@@ -342,7 +328,7 @@ export class WebRTCStream extends AbstractStream {
       // flags can be sent while we or the remote are closing the datachannel so
       // if the channel isn't open, don't try to send it but return false to let
       // the caller know and act if they need to
-      this.log.trace('not sending flag %s because channel is not open', flag.toString())
+      this.log.trace('not sending flag %s because channel is "%s" and not "open"', this.channel.readyState, flag.toString())
       return false
     }