@libp2p/webrtc 5.2.3 → 5.2.4-4939ef7ae

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

@@ -6,7 +6,7 @@ import { IP4, WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { Crypto } from '@peculiar/webcrypto'
 import getPort from 'get-port'
 import pWaitFor from 'p-wait-for'
-import { CODEC_CERTHASH, CODEC_WEBRTC_DIRECT, HANDSHAKE_TIMEOUT_MS } from '../constants.js'
+import { CODEC_CERTHASH, CODEC_WEBRTC_DIRECT } from '../constants.js'
 import { connect } from './utils/connect.js'
 import { generateTransportCertificate } from './utils/generate-certificates.js'
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
@@ -23,6 +23,7 @@ export interface WebRTCDirectListenerComponents {
   peerId: PeerId
   privateKey: PrivateKey
   logger: ComponentLogger
+  upgrader: Upgrader
   metrics?: Metrics
 }
 
@@ -62,6 +63,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
   private readonly init: WebRTCDirectListenerInit
   private readonly components: WebRTCDirectListenerComponents
   private readonly metrics?: WebRTCListenerMetrics
+  private readonly shutdownController: AbortController
 
   constructor (components: WebRTCDirectListenerComponents, init: WebRTCDirectListenerInit) {
     super()
@@ -72,6 +74,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     this.connections = new Map()
     this.log = components.logger.forComponent('libp2p:webrtc-direct:listener')
     this.certificate = init.certificates?.[0]
+    this.shutdownController = new AbortController()
 
     if (components.metrics != null) {
       this.metrics = {
@@ -93,14 +96,14 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       .pop()?.[1]
 
     if (host == null) {
-      throw new Error('IP4/6 host must be specified in webrtc-direct mulitaddr')
+      throw new Error('IP4/6 host must be specified in webrtc-direct multiaddr')
     }
     const port = parseInt(parts
       .filter(([code, value]) => code === UDP_PROTOCOL.code)
       .pop()?.[1] ?? '')
 
     if (isNaN(port)) {
-      throw new Error('UDP port must be specified in webrtc-direct mulitaddr')
+      throw new Error('UDP port must be specified in webrtc-direct multiaddr')
     }
 
     // have to do this before any async work happens so starting two listeners
@@ -178,16 +181,21 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
           }
 
           return stunListener(host, port, this.log, (ufrag, remoteHost, remotePort) => {
-            this.incomingConnection(ufrag, remoteHost, remotePort)
+            const signal = this.components.upgrader.createInboundAbortSignal(this.shutdownController.signal)
+
+            this.incomingConnection(ufrag, remoteHost, remotePort, signal)
               .catch(err => {
                 this.log.error('error processing incoming STUN request', err)
               })
+              .finally(() => {
+                signal.clear()
+              })
           })
         })
     }
   }
 
-  private async incomingConnection (ufrag: string, remoteHost: string, remotePort: number): Promise<void> {
+  private async incomingConnection (ufrag: string, remoteHost: string, remotePort: number, signal: AbortSignal): Promise<void> {
     const key = `${remoteHost}:${remotePort}:${ufrag}`
     let peerConnection = this.connections.get(key)
 
@@ -198,6 +206,9 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
 
     this.log('create peer connection for %s', key)
 
+    // do not create RTCPeerConnection objects if the signal has aborted already
+    signal.throwIfAborted()
+
     // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md#browser-to-public-server
     peerConnection = await createDialerRTCPeerConnection('server', ufrag, this.init.rtcConfiguration, this.certificate)
 
@@ -222,7 +233,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
         logger: this.components.logger,
         metrics: this.components.metrics,
         events: this.metrics?.listenerEvents,
-        signal: AbortSignal.timeout(HANDSHAKE_TIMEOUT_MS),
+        signal,
         remoteAddr: multiaddr(`/ip${isIPv4(remoteHost) ? 4 : 6}/${remoteHost}/udp/${remotePort}`),
         dataChannel: this.init.dataChannel,
         upgrader: this.init.upgrader,
@@ -268,10 +279,6 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
   }
 
   async close (): Promise<void> {
-    for (const connection of this.connections.values()) {
-      connection.close()
-    }
-
     // stop our UDP mux listeners
     await Promise.all(
       UDP_MUX_LISTENERS
@@ -285,6 +292,14 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     // remove our stopped UDP mux listeners
     UDP_MUX_LISTENERS = UDP_MUX_LISTENERS.filter(listener => listener.owner !== this)
 
+    // close existing connections
+    for (const connection of this.connections.values()) {
+      connection.close()
+    }
+
+    // stop any in-progress incoming dials
+    this.shutdownController.abort()
+
     // RTCPeerConnections will be removed from the connections map when their
     // connection state changes to 'closed'/'disconnected'/'failed
     await pWaitFor(() => {

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

@@ -2,14 +2,13 @@ import { serviceCapabilities, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { raceSignal } from 'race-signal'
-import { HANDSHAKE_TIMEOUT_MS } from '../constants.js'
 import { genUfrag } from '../util.js'
 import { WebRTCDirectListener } from './listener.js'
 import { connect } from './utils/connect.js'
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
 import type { DataChannelOptions, TransportCertificate } from '../index.js'
 import type { WebRTCDialEvents } from '../private-to-private/transport.js'
-import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId, DialTransportOptions, PrivateKey } from '@libp2p/interface'
+import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId, DialTransportOptions, PrivateKey, Upgrader } from '@libp2p/interface'
 import type { TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -22,6 +21,7 @@ export interface WebRTCDirectTransportComponents {
   metrics?: Metrics
   logger: ComponentLogger
   transportManager: TransportManager
+  upgrader: Upgrader
 }
 
 export interface WebRTCMetrics {
@@ -72,7 +72,6 @@ export class WebRTCDirectTransport implements Transport {
    * Dial a given multiaddr
    */
   async dial (ma: Multiaddr, options: DialTransportOptions<WebRTCDialEvents>): Promise<Connection> {
-    options?.signal?.throwIfAborted()
     const rawConn = await this._connect(ma, options)
     this.log('dialing address: %a', ma)
     return rawConn
@@ -106,6 +105,9 @@ export class WebRTCDirectTransport implements Transport {
    * Connect to a peer using a multiaddr
    */
   async _connect (ma: Multiaddr, options: DialTransportOptions<WebRTCDialEvents>): Promise<Connection> {
+    // do not create RTCPeerConnection if the signal has already been aborted
+    options.signal.throwIfAborted()
+
     let theirPeerId: PeerId | undefined
     const remotePeerString = ma.getPeerId()
     if (remotePeerString != null) {
@@ -124,7 +126,7 @@ export class WebRTCDirectTransport implements Transport {
         logger: this.components.logger,
         metrics: this.components.metrics,
         events: this.metrics?.dialerEvents,
-        signal: options.signal ?? AbortSignal.timeout(HANDSHAKE_TIMEOUT_MS),
+        signal: options.signal,
         remoteAddr: ma,
         dataChannel: this.init.dataChannel,
         upgrader: options.upgrader,

package/src/private-to-public/utils/generate-noise-prologue.ts

@@ -15,7 +15,7 @@ export function generateNoisePrologue (localFingerprint: string, remoteAddr: Mul
   const localFpString = localFingerprint.trim().toLowerCase().replaceAll(':', '')
   const localFpArray = uint8arrayFromString(localFpString, 'hex')
   const local = Digest.create(sha256.code, localFpArray)
-  const remote: Uint8Array = sdp.mbdecoder.decode(sdp.certhash(remoteAddr))
+  const remote: Uint8Array = sdp.multibaseDecoder.decode(sdp.certhash(remoteAddr))
   const byteLength = PREFIX.byteLength + local.bytes.byteLength + remote.byteLength
 
   if (role === 'server') {

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

@@ -1,8 +1,7 @@
 import { PeerConnection } from '@ipshipyard/node-datachannel'
 import { RTCPeerConnection } from '@ipshipyard/node-datachannel/polyfill'
 import { Crypto } from '@peculiar/webcrypto'
-import { DEFAULT_ICE_SERVERS } from '../../constants.js'
-import { MAX_MESSAGE_SIZE } from '../../stream.js'
+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'

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

@@ -4,9 +4,8 @@ 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 } from '../../constants.js'
+import { CODEC_CERTHASH, MAX_MESSAGE_SIZE } from '../../constants.js'
 import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js'
-import { MAX_MESSAGE_SIZE } from '../../stream.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 
@@ -14,7 +13,7 @@ import type { MultihashDigest } from 'multiformats/hashes/interface'
  * Get base2 | identity decoders
  */
 // @ts-expect-error - Not easy to combine these types.
-export const mbdecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
+export const multibaseDecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
 
 const fingerprintRegex = /^a=fingerprint:(?:\w+-[0-9]+)\s(?<fingerprint>(:?[0-9a-fA-F]{2})+)$/m
 export function getFingerprintFromSdp (sdp: string | undefined): string | undefined {
@@ -42,16 +41,16 @@ export function certhash (ma: Multiaddr): string {
  * Convert a certhash into a multihash
  */
 export function decodeCerthash (certhash: string): MultihashDigest {
-  return digest.decode(mbdecoder.decode(certhash))
+  return digest.decode(multibaseDecoder.decode(certhash))
 }
 
 export function certhashToFingerprint (certhash: string): string {
-  const mbdecoded = decodeCerthash(certhash)
+  const multibaseDecoded = decodeCerthash(certhash)
 
-  return new Array(mbdecoded.bytes.length)
+  return new Array(multibaseDecoded.bytes.length)
     .fill(0)
     .map((val, index) => {
-      return mbdecoded.digest[index].toString(16).padStart(2, '0').toUpperCase()
+      return multibaseDecoded.digest[index].toString(16).padStart(2, '0').toUpperCase()
     })
     .join(':')
 }
@@ -60,9 +59,9 @@ export function certhashToFingerprint (certhash: string): string {
  * Extract the fingerprint from a multiaddr
  */
 export function ma2Fingerprint (ma: Multiaddr): string {
-  const mhdecoded = decodeCerthash(certhash(ma))
-  const prefix = toSupportedHashFunction(mhdecoded.code)
-  const fingerprint = mhdecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')
+  const multihashDecoded = decodeCerthash(certhash(ma))
+  const prefix = toSupportedHashFunction(multihashDecoded.code)
+  const fingerprint = multihashDecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')
   const sdp = fingerprint.match(/.{1,2}/g)
 
   if (sdp == null) {

package/src/stream.ts

@@ -7,8 +7,8 @@ import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
 import { raceEvent } from 'race-event'
 import { raceSignal } from 'race-signal'
-import { encodingLength } from 'uint8-varint'
 import { Uint8ArrayList } from 'uint8arraylist'
+import { BUFFERED_AMOUNT_LOW_TIMEOUT, FIN_ACK_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, OPEN_TIMEOUT, PROTOBUF_OVERHEAD } from './constants.js'
 import { Message } from './private-to-public/pb/message.js'
 import type { DataChannelOptions } from './index.js'
 import type { RTCDataChannel } from './webrtc/index.js'
@@ -27,65 +27,6 @@ export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions
   logger: ComponentLogger
 }
 
-/**
- * How much can be buffered to the DataChannel at once
- */
-export const MAX_BUFFERED_AMOUNT = 2 * 1024 * 1024
-
-/**
- * How long time we wait for the 'bufferedamountlow' event to be emitted
- */
-export const BUFFERED_AMOUNT_LOW_TIMEOUT = 30 * 1000
-
-/**
- * Max message size that can be sent to the DataChannel. In browsers this is
- * 256KiB but go-libp2p and rust-libp2p only support 16KiB at the time of
- * writing.
- *
- * @see https://blog.mozilla.org/webrtc/large-data-channel-messages/
- * @see https://issues.webrtc.org/issues/40644524
- */
-export const MAX_MESSAGE_SIZE = 16 * 1024
-
-/**
- * max protobuf overhead:
- *
- * ```
- * [message-length][flag-field-id+type][flag-field-length][flag-field][message-field-id+type][message-field-length][message-field]
- * ```
- */
-function calculateProtobufOverhead (maxMessageSize = MAX_MESSAGE_SIZE): number {
-  // these have a fixed size
-  const messageLength = encodingLength(maxMessageSize - encodingLength(maxMessageSize))
-  const flagField = 1 + encodingLength(Object.keys(Message.Flag).length - 1) // id+type/value
-  const messageFieldIdType = 1 // id+type
-  const available = maxMessageSize - messageLength - flagField - messageFieldIdType
-
-  // let message-length/message-data fill the rest of the message
-  const messageFieldLengthLength = encodingLength(available)
-
-  return messageLength + flagField + messageFieldIdType + messageFieldLengthLength
-}
-
-/**
- * The protobuf message overhead includes the maximum amount of all bytes in the
- * protobuf that aren't message field bytes
- */
-export const PROTOBUF_OVERHEAD = calculateProtobufOverhead()
-
-/**
- * When closing streams we send a FIN then wait for the remote to
- * reply with a FIN_ACK. If that does not happen within this timeout
- * we close the stream anyway.
- */
-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
@@ -305,10 +246,10 @@ export class WebRTCStream extends AbstractStream {
     while (data.byteLength > 0) {
       const toSend = Math.min(data.byteLength, this.maxMessageSize)
       const buf = data.subarray(0, toSend)
-      const msgbuf = Message.encode({ message: buf })
-      const sendbuf = lengthPrefixed.encode.single(msgbuf)
+      const messageBuf = Message.encode({ message: buf })
+      const sendBuf = lengthPrefixed.encode.single(messageBuf)
       this.log.trace('-> sending message %s', this.channel.readyState)
-      await this._sendMessage(sendbuf)
+      await this._sendMessage(sendBuf)
       this.log.trace('-> sent message %s', this.channel.readyState)
 
       data.consume(toSend)
@@ -411,8 +352,8 @@ export class WebRTCStream extends AbstractStream {
     }
 
     this.log.trace('sending flag %s', flag.toString())
-    const msgbuf = Message.encode({ flag })
-    const prefixedBuf = lengthPrefixed.encode.single(msgbuf)
+    const messageBuf = Message.encode({ flag })
+    const prefixedBuf = lengthPrefixed.encode.single(messageBuf)
 
     try {
       await this._sendMessage(prefixedBuf, false)

package/src/util.ts

@@ -1,7 +1,7 @@
 import { detect } from 'detect-browser'
 import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
-import { DEFAULT_ICE_SERVERS, UFRAG_ALPHABET, UFRAG_PREFIX } from './constants.js'
+import { DATA_CHANNEL_DRAIN_TIMEOUT, DEFAULT_ICE_SERVERS, UFRAG_ALPHABET, UFRAG_PREFIX } from './constants.js'
 import type { RTCDataChannel } from './webrtc/index.js'
 import type { PeerConnection } from '@ipshipyard/node-datachannel'
 import type { LoggerOptions } from '@libp2p/interface'
@@ -13,8 +13,6 @@ export const nopSource = async function * nop (): AsyncGenerator<Uint8Array, any
 
 export const nopSink = async (_: any): Promise<void> => {}
 
-export const DATA_CHANNEL_DRAIN_TIMEOUT = 30 * 1000
-
 export function drainAndClose (channel: RTCDataChannel, direction: string, drainTimeout: number = DATA_CHANNEL_DRAIN_TIMEOUT, options: LoggerOptions): void {
   if (channel.readyState !== 'open') {
     return

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  ".:DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  "TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  ".:TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  "WebRTCDirectTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCDirectTransportComponents.html",
-  "WebRTCTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportComponents.html",
-  "WebRTCTransportDirectInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportDirectInit.html",
-  "WebRTCTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportInit.html",
-  "webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  ".:webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  "webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html",
-  ".:webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html"
-}