@libp2p/tcp 10.1.19-8484de8a2 → 10.1.19-87bc8d4fb

package/dist/src/utils.d.ts

@@ -1,5 +1,5 @@
 import type { Multiaddr } from '@multiformats/multiaddr';
 import type { ListenOptions, IpcSocketConnectOpts, TcpSocketConnectOpts } from 'net';
 export type NetConfig = ListenOptions | (IpcSocketConnectOpts & TcpSocketConnectOpts);
-export declare function multiaddrToNetConfig(addr: Multiaddr, options?: NetConfig): NetConfig;
+export declare function multiaddrToNetConfig(addr: Multiaddr, config?: NetConfig): NetConfig;
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,KAAK,CAAA;AAEpF,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,CAAC,oBAAoB,GAAG,oBAAoB,CAAC,CAAA;AAErF,wBAAgB,oBAAoB,CAAE,IAAI,EAAE,SAAS,EAAE,OAAO,GAAE,SAAc,GAAG,SAAS,CA4BzF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,KAAK,CAAA;AAEpF,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,CAAC,oBAAoB,GAAG,oBAAoB,CAAC,CAAA;AAErF,wBAAgB,oBAAoB,CAAE,IAAI,EAAE,SAAS,EAAE,MAAM,GAAE,SAAc,GAAG,SAAS,CAqBxF"}

package/dist/src/utils.js

@@ -1,16 +1,9 @@
 import os from 'os';
 import path from 'path';
-import { InvalidParametersError } from '@libp2p/interface';
-import { getNetConfig } from '@libp2p/utils';
-import { CODE_UNIX } from '@multiformats/multiaddr';
-import { Unix } from '@multiformats/multiaddr-matcher';
-export function multiaddrToNetConfig(addr, options = {}) {
-    if (Unix.exactMatch(addr)) {
-        const listenPath = addr.getComponents().find(c => c.code === CODE_UNIX)?.value;
-        if (listenPath == null) {
-            throw new InvalidParametersError(`Multiaddr ${addr} was not a Unix address`);
-        }
-        // unix socket listening
+export function multiaddrToNetConfig(addr, config = {}) {
+    const listenPath = addr.getPath();
+    // unix socket listening
+    if (listenPath != null) {
         if (os.platform() === 'win32') {
             // Use named pipes on Windows systems.
             return { path: path.join('\\\\.\\pipe\\', listenPath) };
@@ -19,15 +12,12 @@ export function multiaddrToNetConfig(addr, options = {}) {
             return { path: listenPath };
         }
     }
-    const config = getNetConfig(addr);
-    const host = config.host;
-    const port = config.port;
+    const options = addr.toOptions();
     // tcp listening
     return {
-        host,
-        port,
-        ipv6Only: config.type === 'ip6',
-        ...options
+        ...config,
+        ...options,
+        ipv6Only: options.family === 6
     };
 }
 //# sourceMappingURL=utils.js.map

package/dist/src/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAA;AACnB,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAA;AAMtD,MAAM,UAAU,oBAAoB,CAAE,IAAe,EAAE,UAAqB,EAAE;IAC5E,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,EAAE,KAAK,CAAA;QAE9E,IAAI,UAAU,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,IAAI,sBAAsB,CAAC,aAAa,IAAI,yBAAyB,CAAC,CAAA;QAC9E,CAAC;QAED,wBAAwB;QACxB,IAAI,EAAE,CAAC,QAAQ,EAAE,KAAK,OAAO,EAAE,CAAC;YAC9B,sCAAsC;YACtC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,EAAE,CAAA;QACzD,CAAC;aAAM,CAAC;YACN,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAA;QAC7B,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA;IACjC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;IACxB,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAA;IAExB,gBAAgB;IAChB,OAAO;QACL,IAAI;QACJ,IAAI;QACJ,QAAQ,EAAE,MAAM,CAAC,IAAI,KAAK,KAAK;QAC/B,GAAG,OAAO;KACX,CAAA;AACH,CAAC"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAA;AACnB,OAAO,IAAI,MAAM,MAAM,CAAA;AAMvB,MAAM,UAAU,oBAAoB,CAAE,IAAe,EAAE,SAAoB,EAAE;IAC3E,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,EAAE,CAAA;IAEjC,wBAAwB;IACxB,IAAI,UAAU,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,EAAE,CAAC,QAAQ,EAAE,KAAK,OAAO,EAAE,CAAC;YAC9B,sCAAsC;YACtC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,EAAE,CAAA;QACzD,CAAC;aAAM,CAAC;YACN,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAA;QAC7B,CAAC;IACH,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,EAAE,CAAA;IAEhC,gBAAgB;IAChB,OAAO;QACL,GAAG,MAAM;QACT,GAAG,OAAO;QACV,QAAQ,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC;KAC/B,CAAA;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/tcp",
-  "version": "10.1.19-8484de8a2",
+  "version": "10.1.19-87bc8d4fb",
   "description": "A TCP transport for libp2p",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/transport-tcp#readme",
@@ -53,23 +53,23 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/interface": "2.11.0-8484de8a2",
-    "@libp2p/utils": "6.7.2-8484de8a2",
-    "@multiformats/multiaddr": "^13.0.1",
-    "@multiformats/multiaddr-matcher": "^3.0.1",
+    "@libp2p/interface": "2.11.0-87bc8d4fb",
+    "@libp2p/utils": "6.7.2-87bc8d4fb",
+    "@multiformats/multiaddr": "^12.4.4",
+    "@multiformats/multiaddr-matcher": "^2.0.0",
     "@types/sinon": "^17.0.4",
     "main-event": "^1.0.1",
+    "p-defer": "^4.0.1",
     "p-event": "^6.0.1",
     "progress-events": "^1.0.1",
-    "uint8arraylist": "^2.4.8"
+    "race-event": "^1.3.0",
+    "stream-to-it": "^1.0.1"
   },
   "devDependencies": {
-    "@libp2p/logger": "5.2.0-8484de8a2",
-    "aegir": "^47.0.21",
-    "delay": "^6.0.0",
-    "p-defer": "^4.0.1",
+    "@libp2p/logger": "5.2.0-87bc8d4fb",
+    "aegir": "^47.0.14",
     "p-wait-for": "^5.0.2",
-    "sinon": "^21.0.0",
+    "sinon": "^20.0.0",
     "sinon-ts": "^2.0.0",
     "wherearewe": "^2.0.1"
   },

package/src/index.ts

@@ -59,6 +59,11 @@ export interface TCPOptions {
    */
   outboundSocketInactivityTimeout?: number
 
+  /**
+   * When closing a socket, wait this long for it to close gracefully before it is closed more forcibly
+   */
+  socketCloseTimeout?: number
+
   /**
    * Set this property to reject connections when the server's connection count gets high.
    * https://nodejs.org/api/net.html#servermaxconnections

package/src/listener.ts

@@ -1,6 +1,6 @@
-import net from 'node:net'
+import net from 'net'
 import { AlreadyStartedError, InvalidParametersError, NotStartedError } from '@libp2p/interface'
-import { getThinWaistAddresses } from '@libp2p/utils'
+import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
 import { multiaddr } from '@multiformats/multiaddr'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { pEvent } from 'p-event'
@@ -8,12 +8,13 @@ import { toMultiaddrConnection } from './socket-to-conn.js'
 import { multiaddrToNetConfig } from './utils.js'
 import type { CloseServerOnMaxConnectionsOpts, TCPCreateListenerOptions } from './index.js'
 import type { NetConfig } from './utils.js'
-import type { ComponentLogger, Logger, MultiaddrConnection, CounterGroup, MetricGroup, Metrics, Listener, ListenerEvents, Upgrader, AbortOptions } from '@libp2p/interface'
+import type { ComponentLogger, Logger, MultiaddrConnection, CounterGroup, MetricGroup, Metrics, Listener, ListenerEvents, Upgrader } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 interface Context extends TCPCreateListenerOptions {
   upgrader: Upgrader
-  inactivityTimeout?: number
+  socketInactivityTimeout?: number
+  socketCloseTimeout?: number
   maxConnections?: number
   backlog?: number
   metrics?: Metrics
@@ -60,7 +61,6 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
 
     context.keepAlive = context.keepAlive ?? true
     context.noDelay = context.noDelay ?? true
-    context.allowHalfOpen = context.allowHalfOpen ?? false
 
     this.shutdownController = new AbortController()
     setMaxListeners(Infinity, this.shutdownController.signal)
@@ -161,14 +161,14 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
 
     let maConn: MultiaddrConnection
     try {
-      maConn = toMultiaddrConnection({
-        socket,
-        inactivityTimeout: this.context.inactivityTimeout,
+      maConn = toMultiaddrConnection(socket, {
+        listeningAddr: this.status.listeningAddr,
+        socketInactivityTimeout: this.context.socketInactivityTimeout,
+        socketCloseTimeout: this.context.socketCloseTimeout,
         metrics: this.metrics?.events,
         metricPrefix: `${this.addr} `,
-        direction: 'inbound',
-        localAddr: this.status.listeningAddr,
-        log: this.context.logger.forComponent('libp2p:tcp:connection')
+        logger: this.context.logger,
+        direction: 'inbound'
       })
     } catch (err: any) {
       this.log.error('inbound connection failed', err)
@@ -210,7 +210,6 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
           this.context.closeServerOnMaxConnections != null &&
           this.sockets.size >= this.context.closeServerOnMaxConnections.closeAbove
         ) {
-          this.log('pausing incoming connections as limit is exceeded - %d/%d', this.sockets.size, this.context.closeServerOnMaxConnections.closeAbove)
           this.pause()
         }
       })
@@ -265,11 +264,11 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
     }
   }
 
-  async close (options?: AbortOptions): Promise<void> {
+  async close (): Promise<void> {
     const events: Array<Promise<void>> = []
 
     if (this.server.listening) {
-      events.push(pEvent(this.server, 'close', options))
+      events.push(pEvent(this.server, 'close'))
     }
 
     // shut down the server socket, permanently
@@ -282,7 +281,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
     // the server socket in case new sockets are opened during the shutdown
     this.sockets.forEach(socket => {
       if (socket.readable) {
-        events.push(pEvent(socket, 'close', options))
+        events.push(pEvent(socket, 'close'))
         socket.destroy()
       }
     })
@@ -321,7 +320,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
       return
     }
 
-    this.log('%s server on %s', permanent ? 'closing' : 'pausing', this.server.address())
+    this.log('closing server on %s', this.server.address())
 
     // NodeJS implementation tracks listening status with `this._handle` property.
     // - Server.close() sets this._handle to null immediately. If this._handle is null, NotStartedError is thrown

package/src/socket-to-conn.ts

@@ -1,144 +1,231 @@
 import { InvalidParametersError, TimeoutError } from '@libp2p/interface'
-import { AbstractMultiaddrConnection, ipPortToMultiaddr } from '@libp2p/utils'
-import { Unix } from '@multiformats/multiaddr-matcher'
-import { pEvent } from 'p-event'
-import type { AbortOptions, MultiaddrConnection } from '@libp2p/interface'
-import type { AbstractMultiaddrConnectionInit, SendResult } from '@libp2p/utils'
-import type { Multiaddr } from '@multiformats/multiaddr'
+import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
+import pDefer from 'p-defer'
+import { raceEvent } from 'race-event'
+import { duplex } from 'stream-to-it'
+import { CLOSE_TIMEOUT, SOCKET_TIMEOUT } from './constants.js'
+import { multiaddrToNetConfig } from './utils.js'
+import type { ComponentLogger, MultiaddrConnection, CounterGroup } from '@libp2p/interface'
+import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Socket } from 'net'
-import type { Uint8ArrayList } from 'uint8arraylist'
+import type { DeferredPromise } from 'p-defer'
 
-export interface TCPSocketMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name' | 'stream' | 'remoteAddr'> {
-  socket: Socket
+interface ToConnectionOptions {
+  listeningAddr?: Multiaddr
   remoteAddr?: Multiaddr
+  localAddr?: Multiaddr
+  socketInactivityTimeout?: number
+  socketCloseTimeout?: number
+  metrics?: CounterGroup
+  metricPrefix?: string
+  logger: ComponentLogger
+  direction: 'inbound' | 'outbound'
 }
 
-class TCPSocketMultiaddrConnection extends AbstractMultiaddrConnection {
-  private socket: Socket
+/**
+ * Convert a socket into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptions): MultiaddrConnection => {
+  let closePromise: DeferredPromise<void>
+  const direction = options.direction
+  const metrics = options.metrics
+  const metricPrefix = options.metricPrefix ?? ''
+  const inactivityTimeout = options.socketInactivityTimeout ?? SOCKET_TIMEOUT
+  const closeTimeout = options.socketCloseTimeout ?? CLOSE_TIMEOUT
+  let timedOut = false
+  let errored = false
+
+  // Check if we are connected on a unix path
+  if (options.listeningAddr?.getPath() != null) {
+    options.remoteAddr = options.listeningAddr
+  }
 
-  constructor (init: TCPSocketMultiaddrConnectionInit) {
-    let remoteAddr = init.remoteAddr
+  if (options.remoteAddr?.getPath() != null) {
+    options.localAddr = options.remoteAddr
+  }
 
-    // check if we are connected on a unix path
-    if (init.localAddr != null && Unix.matches(init.localAddr)) {
-      remoteAddr = init.localAddr
-    } else if (remoteAddr == null) {
-      if (init.socket.remoteAddress == null || init.socket.remotePort == null) {
-        // this can be undefined if the socket is destroyed (for example, if the client disconnected)
-        // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#socketremoteaddress
-        throw new InvalidParametersError('Could not determine remote address or port')
-      }
+  // handle socket errors
+  socket.on('error', err => {
+    errored = true
 
-      remoteAddr = ipPortToMultiaddr(init.socket.remoteAddress, init.socket.remotePort)
+    if (!timedOut) {
+      maConn.log.error('%s socket error - %e', direction, err)
+      metrics?.increment({ [`${metricPrefix}error`]: true })
     }
 
-    super({
-      ...init,
-      remoteAddr
-    })
-
-    this.socket = init.socket
-
-    // handle incoming data
-    this.socket.on('data', buf => {
-      this.onData(buf)
-    })
-
-    // handle socket errors
-    this.socket.on('error', err => {
-      this.log('tcp error', remoteAddr, err)
-
-      this.abort(err)
-    })
-
-    // by default there is no timeout
-    // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#socketsettimeouttimeout-callback
-    this.socket.setTimeout(init.inactivityTimeout ?? (2 * 60 * 1_000))
-
-    this.socket.once('timeout', () => {
-      this.log('tcp timeout', remoteAddr)
-      // if the socket times out due to inactivity we must manually close the connection
-      // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#event-timeout
-      this.abort(new TimeoutError())
-    })
-
-    this.socket.once('end', () => {
-      this.log('tcp end', remoteAddr)
-
-      // the remote sent a FIN packet which means no more data will be sent
-      // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#event-end
-      // half open TCP sockets are disabled by default so Node.js should send a
-      // FIN in response to this event and then emit a 'close' event, during
-      // which we tear down the MultiaddrConnection so there is nothing to do
-      // until that occurs
-      this.onTransportClosed()
-    })
-
-    this.socket.once('close', hadError => {
-      this.log('tcp close', remoteAddr)
-
-      if (hadError) {
-        this.abort(new Error('TCP transmission error'))
-        return
-      }
+    socket.destroy()
+    maConn.timeline.close = Date.now()
+  })
 
-      this.onTransportClosed()
-    })
+  let remoteAddr: Multiaddr
 
-    // the socket can accept more data
-    this.socket.on('drain', () => {
-      this.log('tcp drain')
+  if (options.remoteAddr != null) {
+    remoteAddr = options.remoteAddr
+  } else {
+    if (socket.remoteAddress == null || socket.remotePort == null) {
+      // this can be undefined if the socket is destroyed (for example, if the client disconnected)
+      // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#socketremoteaddress
+      throw new InvalidParametersError('Could not determine remote address or port')
+    }
 
-      this.safeDispatchEvent('drain')
-    })
+    remoteAddr = toMultiaddr(socket.remoteAddress, socket.remotePort)
   }
 
-  sendData (data: Uint8ArrayList): SendResult {
-    let sentBytes = 0
-    let canSendMore = true
+  const lOpts = multiaddrToNetConfig(remoteAddr)
+  const lOptsStr = lOpts.path ?? `${lOpts.host ?? ''}:${lOpts.port ?? ''}`
+  const { sink, source } = duplex(socket)
+
+  // by default there is no timeout
+  // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#socketsettimeouttimeout-callback
+  socket.setTimeout(inactivityTimeout)
+
+  socket.once('timeout', () => {
+    timedOut = true
+    maConn.log('%s %s socket read timeout', direction, lOptsStr)
+    metrics?.increment({ [`${metricPrefix}timeout`]: true })
+
+    // if the socket times out due to inactivity we must manually close the connection
+    // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#event-timeout
+    socket.destroy(new TimeoutError())
+    maConn.timeline.close = Date.now()
+  })
+
+  socket.once('close', () => {
+    // record metric for clean exit
+    if (!timedOut && !errored) {
+      maConn.log('%s %s socket close', direction, lOptsStr)
+      metrics?.increment({ [`${metricPrefix}close`]: true })
+    }
+
+    // In instances where `close` was not explicitly called,
+    // such as an iterable stream ending, ensure we have set the close
+    // timeline
+    socket.destroy()
+    maConn.timeline.close = Date.now()
+  })
+
+  socket.once('end', () => {
+    // the remote sent a FIN packet which means no more data will be sent
+    // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#event-end
+    maConn.log('%s %s socket end', direction, lOptsStr)
+    metrics?.increment({ [`${metricPrefix}end`]: true })
+  })
+
+  const maConn: MultiaddrConnection = {
+    async sink (source) {
+      try {
+        await sink((async function * () {
+          for await (const buf of source) {
+            if (buf instanceof Uint8Array) {
+              yield buf
+            } else {
+              yield buf.subarray()
+            }
+          }
+        })())
+      } catch (err: any) {
+        // If aborted we can safely ignore
+        if (err.type !== 'aborted') {
+          // If the source errored the socket will already have been destroyed by
+          // duplex(). If the socket errored it will already be
+          // destroyed. There's nothing to do here except log the error & return.
+          maConn.log.error('%s %s error in sink - %e', direction, lOptsStr, err)
+        }
+      }
+
+      // we have finished writing, send the FIN message
+      socket.end()
+    },
 
-    for (const buf of data) {
-      sentBytes += buf.byteLength
-      canSendMore = this.socket.write(buf)
+    source,
 
-      if (!canSendMore) {
-        break
+    // If the remote address was passed, use it - it may have the peer ID encapsulated
+    remoteAddr,
+
+    timeline: { open: Date.now() },
+
+    async close (options: AbortOptions = {}) {
+      if (socket.closed) {
+        maConn.log('the %s %s socket is already closed', direction, lOptsStr)
+        return
       }
-    }
 
-    return {
-      sentBytes,
-      canSendMore
-    }
-  }
+      if (socket.destroyed) {
+        maConn.log('the %s %s socket is already destroyed', direction, lOptsStr)
+        return
+      }
 
-  async sendClose (options?: AbortOptions): Promise<void> {
-    if (this.socket.destroyed) {
-      return
-    }
+      if (closePromise != null) {
+        return closePromise.promise
+      }
 
-    this.socket.destroySoon()
+      try {
+        closePromise = pDefer()
+
+        // close writable end of socket
+        socket.end()
+
+        // convert EventEmitter to EventTarget
+        const eventTarget = socketToEventTarget(socket)
+
+        // don't wait forever to close
+        const signal = options.signal ?? AbortSignal.timeout(closeTimeout)
+
+        // wait for any unsent data to be sent
+        if (socket.writableLength > 0) {
+          maConn.log('%s %s draining socket', direction, lOptsStr)
+          await raceEvent(eventTarget, 'drain', signal, {
+            errorEvent: 'error'
+          })
+          maConn.log('%s %s socket drained', direction, lOptsStr)
+        }
+
+        await Promise.all([
+          raceEvent(eventTarget, 'close', signal, {
+            errorEvent: 'error'
+          }),
+
+          // all bytes have been sent we can destroy the socket
+          // eslint-disable-next-line @typescript-eslint/await-thenable
+          socket.destroy()
+        ])
+      } catch (err: any) {
+        this.abort(err)
+      } finally {
+        closePromise.resolve()
+      }
+    },
 
-    await pEvent(this.socket, 'close', options)
-  }
+    abort: (err: Error) => {
+      maConn.log('%s %s socket abort due to error - %e', direction, lOptsStr, err)
 
-  sendReset (): void {
-    this.socket.resetAndDestroy()
-  }
+      // the abortSignalListener may already destroyed the socket with an error
+      socket.destroy()
 
-  sendPause (): void {
-    this.socket.pause()
-  }
+      // closing a socket is always asynchronous (must wait for "close" event)
+      // but the tests expect this to be a synchronous operation so we have to
+      // set the close time here. the tests should be refactored to reflect
+      // reality.
+      maConn.timeline.close = Date.now()
+    },
 
-  sendResume (): void {
-    this.socket.resume()
+    log: options.logger.forComponent('libp2p:tcp:connection')
   }
+
+  return maConn
 }
 
-/**
- * Convert a socket into a MultiaddrConnection
- * https://github.com/libp2p/interface-transport#multiaddrconnection
- */
-export const toMultiaddrConnection = (init: TCPSocketMultiaddrConnectionInit): MultiaddrConnection => {
-  return new TCPSocketMultiaddrConnection(init)
+function socketToEventTarget (obj?: any): EventTarget {
+  const eventTarget = {
+    addEventListener: (type: any, cb: any) => {
+      obj.addListener(type, cb)
+    },
+    removeEventListener: (type: any, cb: any) => {
+      obj.removeListener(type, cb)
+    }
+  }
+
+  // @ts-expect-error partial implementation
+  return eventTarget
 }

package/src/tcp.ts

@@ -75,7 +75,6 @@ export class TCP implements Transport<TCPDialEvents> {
   async dial (ma: Multiaddr, options: TCPDialOptions): Promise<Connection> {
     options.keepAlive = options.keepAlive ?? true
     options.noDelay = options.noDelay ?? true
-    options.allowHalfOpen = options.allowHalfOpen ?? false
 
     // options.signal destroys the socket before 'connect' event
     const socket = await this._connect(ma, options)
@@ -83,13 +82,13 @@ export class TCP implements Transport<TCPDialEvents> {
     let maConn: MultiaddrConnection
 
     try {
-      maConn = toMultiaddrConnection({
-        socket,
-        inactivityTimeout: this.opts.outboundSocketInactivityTimeout,
-        metrics: this.metrics?.events,
-        direction: 'outbound',
+      maConn = toMultiaddrConnection(socket, {
         remoteAddr: ma,
-        log: this.log.newScope('connection')
+        socketInactivityTimeout: this.opts.outboundSocketInactivityTimeout,
+        socketCloseTimeout: this.opts.socketCloseTimeout,
+        metrics: this.metrics?.events,
+        logger: this.components.logger,
+        direction: 'outbound'
       })
     } catch (err: any) {
       this.metrics?.errors.increment({ outbound_to_connection: true })
@@ -121,7 +120,7 @@ export class TCP implements Transport<TCPDialEvents> {
         ...options
       }) as (IpcSocketConnectOpts & TcpSocketConnectOpts)
 
-      this.log('dialing %a with opts %o', ma, cOpts)
+      this.log('dialing %a', ma)
       rawSocket = net.connect(cOpts)
 
       const onError = (err: Error): void => {
@@ -193,7 +192,8 @@ export class TCP implements Transport<TCPDialEvents> {
       maxConnections: this.opts.maxConnections,
       backlog: this.opts.backlog,
       closeServerOnMaxConnections: this.opts.closeServerOnMaxConnections,
-      inactivityTimeout: this.opts.inboundSocketInactivityTimeout,
+      socketInactivityTimeout: this.opts.inboundSocketInactivityTimeout,
+      socketCloseTimeout: this.opts.socketCloseTimeout,
       metrics: this.components.metrics,
       logger: this.components.logger
     })

package/src/utils.ts

@@ -1,23 +1,15 @@
 import os from 'os'
 import path from 'path'
-import { InvalidParametersError } from '@libp2p/interface'
-import { getNetConfig } from '@libp2p/utils'
-import { CODE_UNIX } from '@multiformats/multiaddr'
-import { Unix } from '@multiformats/multiaddr-matcher'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ListenOptions, IpcSocketConnectOpts, TcpSocketConnectOpts } from 'net'
 
 export type NetConfig = ListenOptions | (IpcSocketConnectOpts & TcpSocketConnectOpts)
 
-export function multiaddrToNetConfig (addr: Multiaddr, options: NetConfig = {}): NetConfig {
-  if (Unix.exactMatch(addr)) {
-    const listenPath = addr.getComponents().find(c => c.code === CODE_UNIX)?.value
+export function multiaddrToNetConfig (addr: Multiaddr, config: NetConfig = {}): NetConfig {
+  const listenPath = addr.getPath()
 
-    if (listenPath == null) {
-      throw new InvalidParametersError(`Multiaddr ${addr} was not a Unix address`)
-    }
-
-    // unix socket listening
+  // unix socket listening
+  if (listenPath != null) {
     if (os.platform() === 'win32') {
       // Use named pipes on Windows systems.
       return { path: path.join('\\\\.\\pipe\\', listenPath) }
@@ -26,15 +18,12 @@ export function multiaddrToNetConfig (addr: Multiaddr, options: NetConfig = {}):
     }
   }
 
-  const config = getNetConfig(addr)
-  const host = config.host
-  const port = config.port
+  const options = addr.toOptions()
 
   // tcp listening
   return {
-    host,
-    port,
-    ipv6Only: config.type === 'ip6',
-    ...options
+    ...config,
+    ...options,
+    ipv6Only: options.family === 6
   }
 }