@libp2p/webrtc 5.2.24-a02cb0461 → 5.2.24-da78fa851

package/src/muxer.ts

@@ -1,5 +1,4 @@
 import { AbstractStreamMuxer } from '@libp2p/utils'
-import { pEvent } from 'p-event'
 import { MUXER_PROTOCOL } from './constants.js'
 import { createStream, WebRTCStream } from './stream.js'
 import type { DataChannelOptions } from './index.js'
@@ -90,11 +89,12 @@ export class DataChannelMuxer extends AbstractStreamMuxer<WebRTCStream> implemen
      * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event}
      */
     this.peerConnection.ondatachannel = ({ channel }) => {
-      this.log.trace('incoming %s datachannel with channel id %d and status', channel.protocol, channel.id, channel.readyState)
+      this.log.trace('incoming %s datachannel with channel id %d, protocol %s and status %s', channel.protocol, channel.id, channel.protocol, channel.readyState)
 
-      // 'init' channel is only used during connection establishment
+      // 'init' channel is only used during connection establishment, it is
+      // closed by the initiator
       if (channel.label === 'init') {
-        this.log.trace('closing init channel')
+        this.log.trace('closing init channel %d', channel.id)
         channel.close()
 
         return
@@ -114,20 +114,13 @@ export class DataChannelMuxer extends AbstractStreamMuxer<WebRTCStream> implemen
 
   async onCreateStream (options?: CreateStreamOptions): Promise<WebRTCStream> {
     // The spec says the label MUST be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
-    const channel = this.peerConnection.createDataChannel('wtf', {
+    const channel = this.peerConnection.createDataChannel('', {
       // TODO: pre-negotiate stream protocol
-      protocol: options?.protocol
+      // protocol: options?.protocol
     })
 
     this.log('open channel %d for protocol %s', channel.id, options?.protocol)
 
-    if (channel.readyState !== 'open') {
-      this.log('channel %d state is "%s" and not "open", waiting for "open" event before sending data', channel.id, channel.readyState)
-      await pEvent(channel, 'open', options)
-
-      this.log('channel %d state is now "%s", sending data', channel.id, channel.readyState)
-    }
-
     const stream = createStream({
       ...options,
       ...this.dataChannelOptions,

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

@@ -10,9 +10,9 @@ import { splitAddr } from './transport.js'
 import { readCandidatesUntilConnected } from './util.js'
 import type { WebRTCDialEvents, WebRTCTransportMetrics } from './transport.js'
 import type { DataChannelOptions } from '../index.js'
-import type { LoggerOptions, Connection, ComponentLogger } from '@libp2p/interface'
+import type { LoggerOptions, Connection, ComponentLogger, AbortOptions } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
-import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
 
 export interface IncomingStreamOptions extends AbortOptions {
@@ -94,10 +94,20 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
     // setup callback to write ICE candidates to the remote peer
     peerConnection.onicecandidate = ({ candidate }) => {
+      if (peerConnection.connectionState === 'connected') {
+        log.trace('ignore new ice candidate as peer connection is already connected')
+        return
+      }
+
       // 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
+      if (candidate == null || candidate?.candidate === '') {
+        log.trace('initiator detected end of ICE candidates')
+        return
+      }
+
       const data = JSON.stringify(candidate?.toJSON() ?? null)
 
       log.trace('initiator sending ICE candidate %o', candidate)
@@ -178,10 +188,16 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       })
     }
 
-    log.trace('closing init channel, starting status')
-
+    log.trace('closing init channel')
     channel.close()
 
+    // wait for init channel to close before proceeding, otherwise the channel
+    // id can be reused before both sides have seen the channel close
+    log.trace('waiting for init channel to close')
+    await pEvent(channel, 'close', {
+      signal
+    })
+
     onProgress?.(new CustomProgressEvent('webrtc:close-signaling-stream'))
 
     log.trace('closing signaling channel')

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

@@ -3,7 +3,7 @@ import { multiaddr } from '@multiformats/multiaddr'
 import { SDPHandshakeFailedError } from '../error.js'
 import { RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
-import { getConnectionState, getRemotePeer, readCandidatesUntilConnected } from './util.js'
+import { getRemotePeer, readCandidatesUntilConnected } from './util.js'
 import type { RTCPeerConnection } from '../webrtc/index.js'
 import type { AbortOptions, Connection, Logger, PeerId, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -21,10 +21,20 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
   try {
     // candidate callbacks
     peerConnection.onicecandidate = ({ candidate }) => {
+      if (peerConnection.connectionState === 'connected') {
+        log.trace('ignore new ice candidate as peer connection is already connected')
+        return
+      }
+
       // 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
+      if (candidate == null || candidate?.candidate === '') {
+        log.trace('recipient detected end of ICE candidates')
+        return
+      }
+
       const data = JSON.stringify(candidate?.toJSON() ?? null)
 
       log.trace('recipient sending ICE candidate %s', data)
@@ -90,7 +100,7 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
       log
     })
   } catch (err: any) {
-    if (getConnectionState(peerConnection) !== 'connected') {
+    if (peerConnection.connectionState !== 'connected') {
       log.error('error while handling signaling stream from peer %a', connection.remoteAddr, err)
 
       peerConnection.close()

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

@@ -1,7 +1,6 @@
 import { ConnectionFailedError, InvalidMessageError, InvalidMultiaddrError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { CustomProgressEvent } from 'progress-events'
-import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import type { WebRTCDialEvents } from './transport.js'
@@ -28,7 +27,7 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
         connectedPromise.promise,
         stream.read({
           signal: options.signal
-        }).catch(() => {})
+        })
       ])
 
       // stream ended or we became connected
@@ -63,32 +62,33 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
         options.onProgress?.(new CustomProgressEvent<string>('webrtc:add-ice-candidate', candidate.candidate))
         await pc.addIceCandidate(candidate)
       } catch (err) {
-        options.log.error('%s bad candidate received', options.direction, candidateInit, err)
+        options.log.error('%s bad candidate received %o - %e', options.direction, candidateInit, err)
       }
     }
   } catch (err) {
-    options.log.error('%s error parsing ICE candidate', options.direction, err)
+    options.log.error('%s error parsing ICE candidate - %e', options.direction, err)
 
-    if (options.signal?.aborted === true && getConnectionState(pc) !== 'connected') {
+    if (options.signal?.aborted === true && pc.connectionState !== 'connected') {
       throw err
     }
   }
 }
 
-export function getConnectionState (pc: RTCPeerConnection): string {
-  return isFirefox ? pc.iceConnectionState : pc.connectionState
-}
-
 function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
-  pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
-    switch (getConnectionState(pc)) {
+  if (pc.connectionState === 'connected') {
+    promise.resolve()
+    return
+  }
+
+  pc.onconnectionstatechange = (_) => {
+    switch (pc.connectionState) {
       case 'connected':
         promise.resolve()
         break
       case 'failed':
       case 'disconnected':
       case 'closed':
-        promise.reject(new ConnectionFailedError('RTCPeerConnection was closed'))
+        promise.reject(new ConnectionFailedError(`RTCPeerConnection connection state became "${pc.connectionState}"`))
         break
       default:
         break

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

@@ -1,12 +1,11 @@
 import { isIPv4 } from '@chainsafe/is-ip'
 import { InvalidParametersError } from '@libp2p/interface'
-import { getThinWaistAddresses } from '@libp2p/utils'
-import { multiaddr, fromStringTuples } from '@multiformats/multiaddr'
+import { getNetConfig, getThinWaistAddresses } from '@libp2p/utils'
+import { CODE_CERTHASH, CODE_WEBRTC_DIRECT, multiaddr } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import getPort from 'get-port'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import pWaitFor from 'p-wait-for'
-import { CODEC_CERTHASH, CODEC_WEBRTC_DIRECT } from '../constants.js'
 import { connect } from './utils/connect.js'
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
 import { stunListener } from './utils/stun-listener.js'
@@ -94,7 +93,11 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
   }
 
   async listen (ma: Multiaddr): Promise<void> {
-    const { host, port, family } = ma.toOptions()
+    const { host, port, type, protocol } = getNetConfig(ma)
+
+    if (port == null || protocol !== 'udp' || (type !== 'ip4' && type !== 'ip6')) {
+      throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address or was missing a UDP port`)
+    }
 
     let udpMuxServer: UDPMuxServer | undefined
 
@@ -106,7 +109,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       udpMuxServer = UDP_MUX_LISTENERS.find(s => s.port === port)
 
       // make sure the port is free for the given family
-      if (udpMuxServer != null && ((udpMuxServer.isIPv4 && family === 4) || (udpMuxServer.isIPv6 && family === 6))) {
+      if (udpMuxServer != null && ((udpMuxServer.isIPv4 && type === 'ip4') || (udpMuxServer.isIPv6 && type === 'ip6'))) {
         throw new InvalidParametersError(`There is already a listener for ${host}:${port}`)
       }
 
@@ -119,13 +122,13 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     // start the mux server if we don't have one already
     if (udpMuxServer == null) {
       this.log('starting UDP mux server on %s:%p', host, port)
-      udpMuxServer = this.startUDPMuxServer(host, port, family)
+      udpMuxServer = this.startUDPMuxServer(host, port, type === 'ip4' ? 4 : 6)
       UDP_MUX_LISTENERS.push(udpMuxServer)
     }
 
-    if (family === 4) {
+    if (type === 'ip4') {
       udpMuxServer.isIPv4 = true
-    } else if (family === 6) {
+    } else if (type === 'ip6') {
       udpMuxServer.isIPv6 = true
     }
 
@@ -238,19 +241,23 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       }
 
       // add the certhash if it is missing
-      const tuples = ma.stringTuples()
+      const components = ma.getComponents()
 
-      for (let j = 0; j < tuples.length; j++) {
-        if (tuples[j][0] !== CODEC_WEBRTC_DIRECT) {
+      for (let j = 0; j < components.length; j++) {
+        if (components[j].code !== CODE_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])
+        if (components[certhashIndex] == null || components[certhashIndex].code !== CODE_CERTHASH) {
+          components.splice(certhashIndex, 0, {
+            code: CODE_CERTHASH,
+            name: 'certhash',
+            value: this.certificate?.certhash
+          })
 
-          ma = fromStringTuples(tuples)
+          ma = multiaddr(components)
           multiaddrs[i] = ma
         }
       }

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

@@ -1,6 +1,7 @@
 import { generateKeyPair, privateKeyToCryptoKeyPair } from '@libp2p/crypto/keys'
 import { InvalidParametersError, NotFoundError, NotStartedError, serviceCapabilities, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
+import { CODE_P2P } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { BasicConstraintsExtension, X509Certificate, X509CertificateGenerator } from '@peculiar/x509'
 import { Key } from 'interface-datastore'
@@ -164,7 +165,7 @@ export class WebRTCDirectTransport implements Transport, Startable {
     options.signal.throwIfAborted()
 
     let theirPeerId: PeerId | undefined
-    const remotePeerString = ma.getPeerId()
+    const remotePeerString = ma.getComponents().findLast(c => c.code === CODE_P2P)?.value
     if (remotePeerString != null) {
       theirPeerId = peerIdFromString(remotePeerString)
     }

package/src/private-to-public/utils/sdp.ts

@@ -1,10 +1,11 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { multiaddr } from '@multiformats/multiaddr'
+import { getNetConfig } from '@libp2p/utils'
+import { CODE_CERTHASH, multiaddr } from '@multiformats/multiaddr'
 import { base64url } from 'multiformats/bases/base64'
 import { bases, digest } from 'multiformats/basics'
 import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
-import { CODEC_CERTHASH, MAX_MESSAGE_SIZE } from '../../constants.js'
+import { MAX_MESSAGE_SIZE } from '../../constants.js'
 import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
@@ -27,8 +28,8 @@ export function getFingerprintFromSdp (sdp: string | undefined): string | undefi
 
 // Extract the certhash from a multiaddr
 export function certhash (ma: Multiaddr): string {
-  const tups = ma.stringTuples()
-  const certhash = tups.filter((tup) => tup[0] === CODEC_CERTHASH).map((tup) => tup[1])[0]
+  const components = ma.getComponents()
+  const certhash = components.find(c => c.code === CODE_CERTHASH)?.value
 
   if (certhash === undefined || certhash === '') {
     throw new InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
@@ -100,15 +101,20 @@ export function toSupportedHashFunction (code: number): 'sha-1' | 'sha-256' | 's
  * ice-lite mode and DTLS active mode.
  */
 export function serverAnswerFromMultiaddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
-  const { host, port, family } = ma.toOptions()
+  const { host, port, type } = getNetConfig(ma)
+
+  if (type !== 'ip4' && type !== 'ip6') {
+    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+  }
+
   const fingerprint = ma2Fingerprint(ma)
   const sdp = `v=0
-o=- 0 0 IN IP${family} ${host}
+o=- 0 0 IN IP${type === 'ip4' ? 4 : 6} ${host}
 s=-
 t=0 0
 a=ice-lite
 m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
-c=IN IP${family} ${host}
+c=IN IP${type === 'ip4' ? 4 : 6} ${host}
 a=mid:0
 a=ice-options:ice2
 a=ice-ufrag:${ufrag}
@@ -131,11 +137,16 @@ a=end-of-candidates
  * Create an offer SDP message from a multiaddr
  */
 export function clientOfferFromMultiAddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
-  const { host, port, family } = ma.toOptions()
+  const { host, port, type } = getNetConfig(ma)
+
+  if (type !== 'ip4' && type !== 'ip6') {
+    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+  }
+
   const sdp = `v=0
-o=- 0 0 IN IP${family} ${host}
+o=- 0 0 IN IP${type === 'ip4' ? 4 : 6} ${host}
 s=-
-c=IN IP${family} ${host}
+c=IN IP${type === 'ip4' ? 4 : 6} ${host}
 t=0 0
 a=ice-options:ice2,trickle
 m=application ${port} UDP/DTLS/SCTP webrtc-datachannel

package/src/rtcpeerconnection-to-conn.ts

@@ -24,6 +24,10 @@ class RTCPeerConnectionMultiaddrConnection extends AbstractMultiaddrConnection {
       if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
         // nothing else to do but close the connection
         this.onTransportClosed()
+
+        // only necessary with node-datachannel
+        // https://github.com/murat-dogan/node-datachannel/issues/366#issuecomment-3228453155
+        this.peerConnection.close()
       }
     }
   }