@libp2p/webrtc 5.2.23 → 5.2.24-6059227cb

package/src/private-to-public/utils/get-rtcpeerconnection.ts

@@ -1,10 +1,10 @@
-import { PeerConnection } from '@ipshipyard/node-datachannel'
-import { RTCPeerConnection } from '@ipshipyard/node-datachannel/polyfill'
 import { Crypto } from '@peculiar/webcrypto'
+import { PeerConnection } from 'node-datachannel'
+import { RTCPeerConnection } from 'node-datachannel/polyfill'
 import { DEFAULT_ICE_SERVERS, MAX_MESSAGE_SIZE } from '../../constants.js'
 import { generateTransportCertificate } from './generate-certificates.js'
 import type { TransportCertificate } from '../../index.js'
-import type { CertificateFingerprint } from '@ipshipyard/node-datachannel'
+import type { CertificateFingerprint } from 'node-datachannel'
 
 const crypto = new Crypto()
 
@@ -14,7 +14,7 @@ interface DirectRTCPeerConnectionInit extends RTCConfiguration {
 }
 
 export class DirectRTCPeerConnection extends RTCPeerConnection {
-  private readonly peerConnection: PeerConnection
+  private peerConnection: PeerConnection
   private readonly ufrag: string
 
   constructor (init: DirectRTCPeerConnectionInit) {
@@ -22,6 +22,18 @@ export class DirectRTCPeerConnection extends RTCPeerConnection {
 
     this.peerConnection = init.peerConnection
     this.ufrag = init.ufrag
+
+    // make sure C++ peer connection is garbage collected
+    // https://github.com/murat-dogan/node-datachannel/issues/366#issuecomment-3228453155
+    this.addEventListener('connectionstatechange', () => {
+      switch (this.connectionState) {
+        case 'closed':
+          this.peerConnection.close()
+          break
+        default:
+          break
+      }
+    })
   }
 
   async createOffer (): Promise<globalThis.RTCSessionDescriptionInit | any> {

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
@@ -166,8 +177,13 @@ export function munge (desc: RTCSessionDescriptionInit, ufrag: string): RTCSessi
 
   const lineBreak = desc.sdp.includes('\r\n') ? '\r\n' : '\n'
 
-  desc.sdp = desc.sdp
-    .replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak)
-    .replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak)
+  try {
+    desc.sdp = desc.sdp
+      .replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak)
+      .replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak)
+  } catch {
+    // fails under Node.js
+  }
+
   return desc
 }

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

@@ -1,5 +1,5 @@
 import { isIPv4 } from '@chainsafe/is-ip'
-import { IceUdpMuxListener } from '@ipshipyard/node-datachannel'
+import { IceUdpMuxListener } from 'node-datachannel'
 import type { Logger } from '@libp2p/interface'
 import type { AddressInfo } from 'node:net'
 

package/src/rtcpeerconnection-to-conn.ts

@@ -0,0 +1,66 @@
+import { AbstractMultiaddrConnection } from '@libp2p/utils'
+import type { RTCPeerConnection } from './webrtc/index.js'
+import type { AbortOptions, MultiaddrConnection } from '@libp2p/interface'
+import type { AbstractMultiaddrConnectionInit, SendResult } from '@libp2p/utils'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface RTCPeerConnectionMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'stream'> {
+  peerConnection: RTCPeerConnection
+}
+
+class RTCPeerConnectionMultiaddrConnection extends AbstractMultiaddrConnection {
+  private peerConnection: RTCPeerConnection
+
+  constructor (init: RTCPeerConnectionMultiaddrConnectionInit) {
+    super(init)
+
+    this.peerConnection = init.peerConnection
+
+    const initialState = init.peerConnection.connectionState
+
+    this.peerConnection.onconnectionstatechange = () => {
+      this.log.trace('peer connection state change %s initial state %s', this.peerConnection.connectionState, initialState)
+
+      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()
+      }
+    }
+  }
+
+  sendData (data: Uint8ArrayList): SendResult {
+    return {
+      sentBytes: data.byteLength,
+      canSendMore: true
+    }
+  }
+
+  async sendClose (options?: AbortOptions): Promise<void> {
+    this.peerConnection.close()
+    options?.signal?.throwIfAborted()
+  }
+
+  sendReset (): void {
+    this.peerConnection.close()
+  }
+
+  sendPause (): void {
+    // TODO: readable backpressure?
+  }
+
+  sendResume (): void {
+    // TODO: readable backpressure?
+  }
+}
+
+/**
+ * Convert a RTCPeerConnection into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export const toMultiaddrConnection = (init: RTCPeerConnectionMultiaddrConnectionInit): MultiaddrConnection => {
+  return new RTCPeerConnectionMultiaddrConnection(init)
+}