libp2p 0.37.2 → 0.37.3-0bb1b80

package/src/upgrader.ts

@@ -8,14 +8,18 @@ import { codes } from './errors.js'
 import { createConnection } from '@libp2p/connection'
 import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import { peerIdFromString } from '@libp2p/peer-id'
-import type { Connection, ProtocolStream, Stream } from '@libp2p/interfaces/connection'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
-import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interfaces/stream-muxer'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { MultiaddrConnection, Upgrader, UpgraderEvents } from '@libp2p/interfaces/transport'
+import type { MultiaddrConnection, Connection, Stream } from '@libp2p/interface-connection'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
+import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Upgrader, UpgraderEvents } from '@libp2p/interface-transport'
 import type { Duplex } from 'it-stream-types'
-import type { Components } from '@libp2p/interfaces/components'
+import { Components, isInitializable } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { Registrar } from '@libp2p/interface-registrar'
+import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
+import { TimeoutController } from 'timeout-abort-controller'
+import { abortableDuplex } from 'abortable-iterator'
 
 const log = logger('libp2p:upgrader')
 
@@ -41,12 +45,59 @@ export interface CryptoResult extends SecuredConnection {
 export interface UpgraderInit {
   connectionEncryption: ConnectionEncrypter[]
   muxers: StreamMuxerFactory[]
+
+  /**
+   * An amount of ms by which an inbound connection upgrade
+   * must complete
+   */
+  inboundUpgradeTimeout: number
+}
+
+function findIncomingStreamLimit (protocol: string, registrar: Registrar) {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    return options.maxInboundStreams
+  } catch (err: any) {
+    if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
+      throw err
+    }
+  }
+
+  return DEFAULT_MAX_INBOUND_STREAMS
+}
+
+function findOutgoingStreamLimit (protocol: string, registrar: Registrar) {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    return options.maxOutboundStreams
+  } catch (err: any) {
+    if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
+      throw err
+    }
+  }
+
+  return DEFAULT_MAX_OUTBOUND_STREAMS
+}
+
+function countStreams (protocol: string, direction: 'inbound' | 'outbound', connection: Connection) {
+  let streamCount = 0
+
+  connection.streams.forEach(stream => {
+    if (stream.stat.direction === direction && stream.stat.protocol === protocol) {
+      streamCount++
+    }
+  })
+
+  return streamCount
 }
 
 export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upgrader {
   private readonly components: Components
   private readonly connectionEncryption: Map<string, ConnectionEncrypter>
   private readonly muxers: Map<string, StreamMuxerFactory>
+  private readonly inboundUpgradeTimeout: number
 
   constructor (components: Components, init: UpgraderInit) {
     super()
@@ -63,6 +114,8 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     init.muxers.forEach(muxer => {
       this.muxers.set(muxer.protocol, muxer)
     })
+
+    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout
   }
 
   /**
@@ -78,82 +131,92 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     let proxyPeer
     const metrics = this.components.getMetrics()
 
-    if (await this.components.getConnectionGater().denyInboundConnection(maConn)) {
-      throw errCode(new Error('The multiaddr connection is blocked by gater.acceptConnection'), codes.ERR_CONNECTION_INTERCEPTED)
-    }
+    const timeoutController = new TimeoutController(this.inboundUpgradeTimeout)
 
-    if (metrics != null) {
-      ({ setTarget: setPeer, proxy: proxyPeer } = mutableProxy())
-      const idString = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
-      setPeer({ toString: () => idString })
-      maConn = metrics.trackStream({ stream: maConn, remotePeer: proxyPeer })
-    }
+    try {
+      const abortableStream = abortableDuplex(maConn, timeoutController.signal)
+      maConn.source = abortableStream.source
+      maConn.sink = abortableStream.sink
 
-    log('starting the inbound connection upgrade')
+      if (await this.components.getConnectionGater().denyInboundConnection(maConn)) {
+        throw errCode(new Error('The multiaddr connection is blocked by gater.acceptConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+      }
 
-    // Protect
-    let protectedConn = maConn
-    const protector = this.components.getConnectionProtector()
+      if (metrics != null) {
+        ({ setTarget: setPeer, proxy: proxyPeer } = mutableProxy())
+        const idString = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
+        setPeer({ toString: () => idString })
+        maConn = metrics.trackStream({ stream: maConn, remotePeer: proxyPeer })
+      }
 
-    if (protector != null) {
-      log('protecting the inbound connection')
-      protectedConn = await protector.protect(maConn)
-    }
+      log('starting the inbound connection upgrade')
 
-    try {
-      // Encrypt the connection
-      ({
-        conn: encryptedConn,
-        remotePeer,
-        protocol: cryptoProtocol
-      } = await this._encryptInbound(protectedConn))
+      // Protect
+      let protectedConn = maConn
+      const protector = this.components.getConnectionProtector()
+
+      if (protector != null) {
+        log('protecting the inbound connection')
+        protectedConn = await protector.protect(maConn)
+      }
+
+      try {
+        // Encrypt the connection
+        ({
+          conn: encryptedConn,
+          remotePeer,
+          protocol: cryptoProtocol
+        } = await this._encryptInbound(protectedConn))
+
+        if (await this.components.getConnectionGater().denyInboundEncryptedConnection(remotePeer, {
+          ...protectedConn,
+          ...encryptedConn
+        })) {
+          throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+        }
+
+        // Multiplex the connection
+        if (this.muxers.size > 0) {
+          const multiplexed = await this._multiplexInbound({
+            ...protectedConn,
+            ...encryptedConn
+          }, this.muxers)
+          muxerFactory = multiplexed.muxerFactory
+          upgradedConn = multiplexed.stream
+        } else {
+          upgradedConn = encryptedConn
+        }
+      } catch (err: any) {
+        log.error('Failed to upgrade inbound connection', err)
+        await maConn.close(err)
+        throw err
+      }
 
-      if (await this.components.getConnectionGater().denyInboundEncryptedConnection(remotePeer, {
+      if (await this.components.getConnectionGater().denyInboundUpgradedConnection(remotePeer, {
         ...protectedConn,
         ...encryptedConn
       })) {
         throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
       }
 
-      // Multiplex the connection
-      if (this.muxers.size > 0) {
-        const multiplexed = await this._multiplexInbound({
-          ...protectedConn,
-          ...encryptedConn
-        }, this.muxers)
-        muxerFactory = multiplexed.muxerFactory
-        upgradedConn = multiplexed.stream
-      } else {
-        upgradedConn = encryptedConn
+      if (metrics != null) {
+        metrics.updatePlaceholder(proxyPeer, remotePeer)
+        setPeer(remotePeer)
       }
-    } catch (err: any) {
-      log.error('Failed to upgrade inbound connection', err)
-      await maConn.close(err)
-      throw err
-    }
 
-    if (await this.components.getConnectionGater().denyInboundUpgradedConnection(remotePeer, {
-      ...protectedConn,
-      ...encryptedConn
-    })) {
-      throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
-    }
+      log('Successfully upgraded inbound connection')
 
-    if (metrics != null) {
-      metrics.updatePlaceholder(proxyPeer, remotePeer)
-      setPeer(remotePeer)
+      return this._createConnection({
+        cryptoProtocol,
+        direction: 'inbound',
+        maConn,
+        upgradedConn,
+        muxerFactory,
+        remotePeer
+      })
+    } finally {
+      timeoutController.clear()
     }
-
-    log('Successfully upgraded inbound connection')
-
-    return this._createConnection({
-      cryptoProtocol,
-      direction: 'inbound',
-      maConn,
-      upgradedConn,
-      muxerFactory,
-      remotePeer
-    })
   }
 
   /**
@@ -267,12 +330,13 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     } = opts
 
     let muxer: StreamMuxer | undefined
-    let newStream: ((multicodecs: string[], options?: AbortOptions) => Promise<ProtocolStream>) | undefined
+    let newStream: ((multicodecs: string[], options?: AbortOptions) => Promise<Stream>) | undefined
     let connection: Connection // eslint-disable-line prefer-const
 
     if (muxerFactory != null) {
       // Create the muxer
-      muxer = muxerFactory.createStreamMuxer(this.components, {
+      muxer = muxerFactory.createStreamMuxer({
+        direction,
         // Run anytime a remote stream is created
         onIncomingStream: muxedStream => {
           if (connection == null) {
@@ -296,11 +360,24 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
                 return
               }
 
-              connection.addStream(muxedStream, { protocol })
+              const incomingLimit = findIncomingStreamLimit(protocol, this.components.getRegistrar())
+              const streamCount = countStreams(protocol, 'inbound', connection)
+
+              if (streamCount === incomingLimit) {
+                throw errCode(new Error('Too many incoming protocol streams'), codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS)
+              }
+
+              muxedStream.stat.protocol = protocol
+
+              connection.addStream(muxedStream)
               this._onStream({ connection, stream: { ...muxedStream, ...stream }, protocol })
             })
             .catch(err => {
               log.error(err)
+
+              if (muxedStream.stat.timeline.close == null) {
+                muxedStream.close()
+              }
             })
         },
         // Run anytime a stream closes
@@ -309,7 +386,11 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         }
       })
 
-      newStream = async (protocols: string[], options: AbortOptions = {}): Promise<ProtocolStream> => {
+      if (isInitializable(muxer)) {
+        muxer.init(this.components)
+      }
+
+      newStream = async (protocols: string[], options: AbortOptions = {}): Promise<Stream> => {
         if (muxer == null) {
           throw errCode(new Error('Stream is not multiplexed'), codes.ERR_MUXER_UNAVAILABLE)
         }
@@ -318,23 +399,55 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         const muxedStream = muxer.newStream()
         const mss = new Dialer(muxedStream)
         const metrics = this.components.getMetrics()
+        let controller: TimeoutController | undefined
 
         try {
+          if (options.signal == null) {
+            log('No abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
+
+            controller = new TimeoutController(30000)
+            options.signal = controller.signal
+          }
+
           let { stream, protocol } = await mss.select(protocols, options)
 
           if (metrics != null) {
             stream = metrics.trackStream({ stream, remotePeer, protocol })
           }
 
-          return { stream: { ...muxedStream, ...stream }, protocol }
+          const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.getRegistrar())
+          const streamCount = countStreams(protocol, 'outbound', connection)
+
+          if (streamCount === outgoingLimit) {
+            throw errCode(new Error('Too many outgoing protocol streams'), codes.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS)
+          }
+
+          muxedStream.stat.protocol = protocol
+
+          return {
+            ...muxedStream,
+            ...stream,
+            stat: {
+              ...muxedStream.stat,
+              protocol
+            }
+          }
         } catch (err: any) {
           log.error('could not create new stream', err)
 
+          if (muxedStream.stat.timeline.close == null) {
+            muxedStream.close()
+          }
+
           if (err.code != null) {
             throw err
           }
 
           throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL)
+        } finally {
+          if (controller != null) {
+            controller.clear()
+          }
         }
       }
 
@@ -390,9 +503,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         await maConn.close()
         // Ensure remaining streams are closed
         if (muxer != null) {
-          await Promise.all(muxer.streams.map(async stream => {
-            await stream.close()
-          }))
+          muxer.close()
         }
       }
     })
@@ -409,8 +520,9 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    */
   _onStream (opts: OnStreamOptions): void {
     const { connection, stream, protocol } = opts
-    const handler = this.components.getRegistrar().getHandler(protocol)
-    handler({ connection, stream, protocol })
+    const { handler } = this.components.getRegistrar().getHandler(protocol)
+
+    handler({ connection, stream })
   }
 
   /**

package/src/version.ts

@@ -1,3 +1,2 @@
-
-export const version = '0.0.0'
+export const version = '0.37.3-0bb1b80'
 export const name = 'libp2p'