@libp2p/autonat-v2 1.0.1 → 2.0.0-049bfa0fa

package/src/client.ts

@@ -1,23 +1,16 @@
-import { ProtocolError, serviceCapabilities, serviceDependencies } from '@libp2p/interface'
+import { InvalidParametersError, ProtocolError, serviceCapabilities, serviceDependencies } from '@libp2p/interface'
 import { peerSet } from '@libp2p/peer-collections'
-import { createScalableCuckooFilter } from '@libp2p/utils/filters'
-import { isGlobalUnicast } from '@libp2p/utils/multiaddr/is-global-unicast'
-import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
-import { PeerQueue } from '@libp2p/utils/peer-queue'
-import { repeatingTask } from '@libp2p/utils/repeating-task'
-import { trackedMap } from '@libp2p/utils/tracked-map'
+import { createScalableCuckooFilter, isGlobalUnicast, isPrivate, PeerQueue, repeatingTask, trackedMap, pbStream, getNetConfig } from '@libp2p/utils'
 import { anySignal } from 'any-signal'
-import { pbStream } from 'it-protobuf-stream'
 import { setMaxListeners } from 'main-event'
 import { DEFAULT_CONNECTION_THRESHOLD, DIAL_DATA_CHUNK_SIZE, MAX_DIAL_DATA_BYTES, MAX_INBOUND_STREAMS, MAX_MESSAGE_SIZE, MAX_OUTBOUND_STREAMS, TIMEOUT } from './constants.ts'
 import { DialBack, DialBackResponse, DialResponse, DialStatus, Message } from './pb/index.ts'
 import { randomNumber } from './utils.ts'
 import type { AutoNATv2Components, AutoNATv2ServiceInit } from './index.ts'
-import type { Logger, Connection, Startable, AbortOptions, IncomingStreamData } from '@libp2p/interface'
+import type { Logger, Connection, Startable, AbortOptions, Stream } from '@libp2p/interface'
 import type { AddressType } from '@libp2p/interface-internal'
 import type { PeerSet } from '@libp2p/peer-collections'
-import type { Filter } from '@libp2p/utils/filters'
-import type { RepeatingTask } from '@libp2p/utils/repeating-task'
+import type { Filter, RepeatingTask } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 // if more than 3 peers manage to dial us on what we believe to be our external
@@ -154,8 +147,8 @@ export class AutoNATv2Client implements Startable {
       }
     })
 
-    await this.components.registrar.handle(this.dialBackProtocol, (data) => {
-      void this.handleDialBackStream(data)
+    await this.components.registrar.handle(this.dialBackProtocol, (stream, connection) => {
+      void this.handleDialBackStream(stream, connection)
         .catch(err => {
           this.log.error('error handling incoming autonat stream - %e', err)
         })
@@ -239,11 +232,11 @@ export class AutoNATv2Client implements Startable {
   /**
    * Handle an incoming AutoNAT request
    */
-  async handleDialBackStream (data: IncomingStreamData): Promise<void> {
+  async handleDialBackStream (stream: Stream, connection: Connection): Promise<void> {
     const signal = AbortSignal.timeout(this.timeout)
     setMaxListeners(Infinity, signal)
 
-    const messages = pbStream(data.stream, {
+    const messages = pbStream(stream, {
       maxDataLength: this.maxMessageSize
     })
 
@@ -264,12 +257,12 @@ export class AutoNATv2Client implements Startable {
         status: DialBackResponse.DialBackStatus.OK
       }, DialBackResponse)
 
-      await data.stream.close({
+      await stream.close({
         signal
       })
     } catch (err: any) {
       this.log.error('error handling incoming dial back stream - %e', err)
-      data.stream.abort(err)
+      stream.abort(err)
     }
   }
 
@@ -295,9 +288,9 @@ export class AutoNATv2Client implements Startable {
           return false
         }
 
-        const options = addr.multiaddr.toOptions()
+        const options = getNetConfig(addr.multiaddr)
 
-        if (options.family === 6) {
+        if (options.type === 'ip6') {
           // do not send IPv6 addresses to peers without IPv6 addresses
           if (!supportsIPv6) {
             return false
@@ -409,7 +402,7 @@ export class AutoNATv2Client implements Startable {
     // if the remote peer has IPv6 addresses, we can probably send them an IPv6
     // address to verify, otherwise only send them IPv4 addresses
     const supportsIPv6 = peer.addresses.some(({ multiaddr }) => {
-      return multiaddr.toOptions().family === 6
+      return getNetConfig(multiaddr).type === 'ip6'
     })
 
     // get multiaddrs this peer is eligible to verify
@@ -465,7 +458,7 @@ export class AutoNATv2Client implements Startable {
       return
     }
 
-    this.log.trace('asking %p to verify multiaddrs %s', connection.remotePeer, unverifiedAddresses)
+    this.log.trace('asking %a to verify multiaddrs %s', connection.remoteAddr, unverifiedAddresses)
 
     const stream = await connection.newStream(this.dialRequestProtocol, options)
 
@@ -478,7 +471,7 @@ export class AutoNATv2Client implements Startable {
         }
       }, options)
 
-      while (true) {
+      for (let i = 0; i < unverifiedAddresses.length; i++) {
         let response = await messages.read(options)
 
         if (response.dialDataRequest != null) {
@@ -615,14 +608,20 @@ export class AutoNATv2Client implements Startable {
 
   private getNetworkSegment (ma: Multiaddr): string {
     // make sure we use different network segments
-    const options = ma.toOptions()
+    const options = getNetConfig(ma)
 
-    if (options.family === 4) {
-      const octets = options.host.split('.')
-      return octets[0].padStart(3, '0')
+    switch (options.type) {
+      case 'ip4': {
+        const octets = options.host.split('.')
+        return octets[0].padStart(3, '0')
+      }
+      case 'ip6': {
+        const octets = options.host.split(':')
+        return octets[0].padStart(4, '0')
+      }
+      default: {
+        throw new InvalidParametersError(`Remote address ${ma} was not an IPv4 or Ipv6 address`)
+      }
     }
-
-    const octets = options.host.split(':')
-    return octets[0].padStart(4, '0')
   }
 }

package/src/server.ts

@@ -1,15 +1,14 @@
 import { ProtocolError } from '@libp2p/interface'
-import { isPrivateIp } from '@libp2p/utils/private-ip'
+import { isPrivateIp, pbStream } from '@libp2p/utils'
 import { CODE_IP4, CODE_IP6, multiaddr } from '@multiformats/multiaddr'
-import { pbStream } from 'it-protobuf-stream'
 import { setMaxListeners } from 'main-event'
 import { MAX_INBOUND_STREAMS, MAX_MESSAGE_SIZE, MAX_OUTBOUND_STREAMS, TIMEOUT } from './constants.ts'
 import { DialBack, DialBackResponse, DialResponse, DialStatus, Message } from './pb/index.ts'
 import { randomNumber } from './utils.ts'
 import type { AutoNATv2Components, AutoNATv2ServiceInit } from './index.ts'
-import type { Logger, Connection, Startable, AbortOptions, IncomingStreamData, Stream } from '@libp2p/interface'
+import type { Logger, Connection, Startable, AbortOptions, Stream } from '@libp2p/interface'
+import type { ProtobufMessageStream } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { MessageStream } from 'it-protobuf-stream'
 
 export interface AutoNATv2ServerInit extends AutoNATv2ServiceInit {
   dialRequestProtocol: string
@@ -37,6 +36,8 @@ export class AutoNATv2Server implements Startable {
     this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS
     this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS
     this.maxMessageSize = init.maxMessageSize ?? MAX_MESSAGE_SIZE
+
+    this.handleDialRequestStream = this.handleDialRequestStream.bind(this)
   }
 
   async start (): Promise<void> {
@@ -45,12 +46,7 @@ export class AutoNATv2Server implements Startable {
     }
 
     // AutoNat server
-    await this.components.registrar.handle(this.dialRequestProtocol, (data) => {
-      void this.handleDialRequestStream(data)
-        .catch(err => {
-          this.log.error('error handling incoming autonat stream - %e', err)
-        })
-    }, {
+    await this.components.registrar.handle(this.dialRequestProtocol, this.handleDialRequestStream, {
       maxInboundStreams: this.maxInboundStreams,
       maxOutboundStreams: this.maxOutboundStreams
     })
@@ -67,100 +63,95 @@ export class AutoNATv2Server implements Startable {
   /**
    * Handle an incoming AutoNAT request
    */
-  async handleDialRequestStream (data: IncomingStreamData): Promise<void> {
+  async handleDialRequestStream (stream: Stream, connection: Connection): Promise<void> {
     const signal = AbortSignal.timeout(this.timeout)
     setMaxListeners(Infinity, signal)
 
-    const messages = pbStream(data.stream, {
+    const messages = pbStream(stream, {
       maxDataLength: this.maxMessageSize
     }).pb(Message)
 
-    try {
-      const connectionIp = getIpAddress(data.connection.remoteAddr)
+    const connectionIp = getIpAddress(connection.remoteAddr)
 
-      if (connectionIp == null) {
-        throw new ProtocolError(`Could not find IP address in connection address "${data.connection.remoteAddr}"`)
-      }
+    if (connectionIp == null) {
+      throw new ProtocolError(`Could not find IP address in connection address "${connection.remoteAddr}"`)
+    }
 
-      const { dialRequest } = await messages.read({
-        signal
-      })
+    const { dialRequest } = await messages.read({
+      signal
+    })
 
-      if (dialRequest == null) {
-        throw new ProtocolError('Did not receive DialRequest message on incoming dial request stream')
-      }
+    if (dialRequest == null) {
+      throw new ProtocolError('Did not receive DialRequest message on incoming dial request stream')
+    }
 
-      if (dialRequest.addrs.length === 0) {
-        throw new ProtocolError('Did not receive any addresses to dial')
-      }
+    if (dialRequest.addrs.length === 0) {
+      throw new ProtocolError('Did not receive any addresses to dial')
+    }
 
-      for (let i = 0; i < dialRequest.addrs.length; i++) {
-        try {
-          const ma = multiaddr(dialRequest.addrs[i])
-          const isDialable = await this.components.connectionManager.isDialable(ma, {
+    for (let i = 0; i < dialRequest.addrs.length; i++) {
+      try {
+        const ma = multiaddr(dialRequest.addrs[i])
+        const isDialable = await this.components.connectionManager.isDialable(ma, {
+          signal
+        })
+
+        if (!isDialable) {
+          await messages.write({
+            dialResponse: {
+              addrIdx: i,
+              status: DialResponse.ResponseStatus.E_DIAL_REFUSED,
+              dialStatus: DialStatus.UNUSED
+            }
+          }, {
             signal
           })
 
-          if (!isDialable) {
-            await messages.write({
-              dialResponse: {
-                addrIdx: i,
-                status: DialResponse.ResponseStatus.E_DIAL_REFUSED,
-                dialStatus: DialStatus.UNUSED
-              }
-            }, {
-              signal
-            })
-
-            continue
-          }
-
-          const ip = getIpAddress(ma)
-
-          if (ip == null) {
-            throw new ProtocolError(`Could not find IP address in requested address "${ma}"`)
-          }
+          continue
+        }
 
-          if (isPrivateIp(ip)) {
-            throw new ProtocolError(`Requested address had private IP "${ma}"`)
-          }
+        const ip = getIpAddress(ma)
 
-          if (ip !== connectionIp) {
-            // amplification attack protection - request the client sends us a
-            // random number of bytes before we'll dial the address
-            await this.preventAmplificationAttack(messages, i, {
-              signal
-            })
-          }
+        if (ip == null) {
+          throw new ProtocolError(`Could not find IP address in requested address "${ma}"`)
+        }
 
-          const dialStatus = await this.dialClientBack(ma, dialRequest.nonce, {
-            signal
-          })
+        if (isPrivateIp(ip)) {
+          throw new ProtocolError(`Requested address had private IP "${ma}"`)
+        }
 
-          await messages.write({
-            dialResponse: {
-              addrIdx: i,
-              status: DialResponse.ResponseStatus.OK,
-              dialStatus
-            }
-          }, {
+        if (ip !== connectionIp) {
+          // amplification attack protection - request the client sends us a
+          // random number of bytes before we'll dial the address
+          await this.preventAmplificationAttack(messages, i, {
             signal
           })
-        } catch (err) {
-          this.log.error('could not parse multiaddr - %e', err)
         }
-      }
 
-      await data.stream.close({
-        signal
-      })
-    } catch (err: any) {
-      this.log.error('error handling incoming autonat stream - %e', err)
-      data.stream.abort(err)
+        const dialStatus = await this.dialClientBack(ma, dialRequest.nonce, {
+          signal
+        })
+
+        await messages.write({
+          dialResponse: {
+            addrIdx: i,
+            status: DialResponse.ResponseStatus.OK,
+            dialStatus
+          }
+        }, {
+          signal
+        })
+      } catch (err) {
+        this.log.error('error handling incoming dialback request - %e', err)
+      }
     }
+
+    await stream.close({
+      signal
+    })
   }
 
-  private async preventAmplificationAttack (messages: MessageStream<Message, Stream>, index: number, options: AbortOptions): Promise<void> {
+  private async preventAmplificationAttack (messages: ProtobufMessageStream<Message, Stream>, index: number, options: AbortOptions): Promise<void> {
     const numBytes = randomNumber(30_000, 100_000)
 
     await messages.write({
@@ -207,7 +198,7 @@ export class AutoNATv2Server implements Startable {
         nonce
       }, DialBack, options)
 
-      const response = await dialBackMessages.read(DialBackResponse)
+      const response = await dialBackMessages.read(DialBackResponse, options)
 
       if (response.status !== DialBackResponse.DialBackStatus.OK) {
         throw new ProtocolError('DialBackResponse status was not OK')

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "AutoNATv2Components": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat-v2.AutoNATv2Components.html",
-  ".:AutoNATv2Components": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat-v2.AutoNATv2Components.html",
-  "AutoNATv2ServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat-v2.AutoNATv2ServiceInit.html",
-  ".:AutoNATv2ServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_autonat-v2.AutoNATv2ServiceInit.html",
-  "autoNATv2": "https://libp2p.github.io/js-libp2p/functions/_libp2p_autonat-v2.autoNATv2.html",
-  ".:autoNATv2": "https://libp2p.github.io/js-libp2p/functions/_libp2p_autonat-v2.autoNATv2.html"
-}