@libp2p/tcp 10.1.19 → 11.0.0-049bfa0fa

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, config?: NetConfig): NetConfig;
+export declare function multiaddrToNetConfig(addr: Multiaddr, options?: 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":"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"}
+{"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"}

package/dist/src/utils.js

@@ -1,9 +1,16 @@
 import os from 'os';
 import path from 'path';
-export function multiaddrToNetConfig(addr, config = {}) {
-    const listenPath = addr.getPath();
-    // unix socket listening
-    if (listenPath != null) {
+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
         if (os.platform() === 'win32') {
             // Use named pipes on Windows systems.
             return { path: path.join('\\\\.\\pipe\\', listenPath) };
@@ -12,12 +19,15 @@ export function multiaddrToNetConfig(addr, config = {}) {
             return { path: listenPath };
         }
     }
-    const options = addr.toOptions();
+    const config = getNetConfig(addr);
+    const host = config.host;
+    const port = config.port;
     // tcp listening
     return {
-        ...config,
-        ...options,
-        ipv6Only: options.family === 6
+        host,
+        port,
+        ipv6Only: config.type === 'ip6',
+        ...options
     };
 }
 //# 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;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"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/tcp",
-  "version": "10.1.19",
+  "version": "11.0.0-049bfa0fa",
   "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",
-    "@libp2p/utils": "^6.7.2",
-    "@multiformats/multiaddr": "^12.4.4",
-    "@multiformats/multiaddr-matcher": "^2.0.0",
+    "@libp2p/interface": "3.0.0-049bfa0fa",
+    "@libp2p/utils": "7.0.0-049bfa0fa",
+    "@multiformats/multiaddr": "^13.0.1",
+    "@multiformats/multiaddr-matcher": "^3.0.1",
     "@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",
-    "race-event": "^1.3.0",
-    "stream-to-it": "^1.0.1"
+    "uint8arraylist": "^2.4.8"
   },
   "devDependencies": {
-    "@libp2p/logger": "^5.2.0",
-    "aegir": "^47.0.14",
+    "@libp2p/logger": "6.0.0-049bfa0fa",
+    "aegir": "^47.0.22",
+    "delay": "^6.0.0",
+    "p-defer": "^4.0.1",
     "p-wait-for": "^5.0.2",
-    "sinon": "^20.0.0",
+    "sinon": "^21.0.0",
     "sinon-ts": "^2.0.0",
     "wherearewe": "^2.0.1"
   },

package/src/index.ts

@@ -59,11 +59,6 @@ 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 'net'
+import net from 'node:net'
 import { AlreadyStartedError, InvalidParametersError, NotStartedError } from '@libp2p/interface'
-import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
+import { getThinWaistAddresses } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { pEvent } from 'p-event'
@@ -8,13 +8,12 @@ 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 } from '@libp2p/interface'
+import type { ComponentLogger, Logger, MultiaddrConnection, CounterGroup, MetricGroup, Metrics, Listener, ListenerEvents, Upgrader, AbortOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 interface Context extends TCPCreateListenerOptions {
   upgrader: Upgrader
-  socketInactivityTimeout?: number
-  socketCloseTimeout?: number
+  inactivityTimeout?: number
   maxConnections?: number
   backlog?: number
   metrics?: Metrics
@@ -61,6 +60,7 @@ 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, {
-        listeningAddr: this.status.listeningAddr,
-        socketInactivityTimeout: this.context.socketInactivityTimeout,
-        socketCloseTimeout: this.context.socketCloseTimeout,
+      maConn = toMultiaddrConnection({
+        socket,
+        inactivityTimeout: this.context.inactivityTimeout,
         metrics: this.metrics?.events,
         metricPrefix: `${this.addr} `,
-        logger: this.context.logger,
-        direction: 'inbound'
+        direction: 'inbound',
+        localAddr: this.status.listeningAddr,
+        log: this.context.logger.forComponent('libp2p:tcp:connection')
       })
     } catch (err: any) {
       this.log.error('inbound connection failed', err)
@@ -210,6 +210,7 @@ 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()
         }
       })
@@ -264,11 +265,11 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
     }
   }
 
-  async close (): Promise<void> {
+  async close (options?: AbortOptions): Promise<void> {
     const events: Array<Promise<void>> = []
 
     if (this.server.listening) {
-      events.push(pEvent(this.server, 'close'))
+      events.push(pEvent(this.server, 'close', options))
     }
 
     // shut down the server socket, permanently
@@ -281,7 +282,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'))
+        events.push(pEvent(socket, 'close', options))
         socket.destroy()
       }
     })
@@ -320,7 +321,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
       return
     }
 
-    this.log('closing server on %s', this.server.address())
+    this.log('%s server on %s', permanent ? 'closing' : 'pausing', 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,230 +1,144 @@
 import { InvalidParametersError, TimeoutError } from '@libp2p/interface'
-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 { 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 type { Socket } from 'net'
-import type { DeferredPromise } from 'p-defer'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
-interface ToConnectionOptions {
-  listeningAddr?: Multiaddr
+export interface TCPSocketMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'name' | 'stream' | 'remoteAddr'> {
+  socket: Socket
   remoteAddr?: Multiaddr
-  localAddr?: Multiaddr
-  socketInactivityTimeout?: number
-  socketCloseTimeout?: number
-  metrics?: CounterGroup
-  metricPrefix?: string
-  logger: ComponentLogger
-  direction: 'inbound' | 'outbound'
 }
 
-/**
- * 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
-  }
-
-  if (options.remoteAddr?.getPath() != null) {
-    options.localAddr = options.remoteAddr
-  }
-
-  // handle socket errors
-  socket.on('error', err => {
-    errored = true
-
-    if (!timedOut) {
-      maConn.log.error('%s socket error - %e', direction, err)
-      metrics?.increment({ [`${metricPrefix}error`]: true })
-    }
-
-    socket.destroy()
-    maConn.timeline.close = Date.now()
-  })
+class TCPSocketMultiaddrConnection extends AbstractMultiaddrConnection {
+  private socket: Socket
 
-  let remoteAddr: Multiaddr
+  constructor (init: TCPSocketMultiaddrConnectionInit) {
+    let remoteAddr = init.remoteAddr
 
-  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')
-    }
-
-    remoteAddr = toMultiaddr(socket.remoteAddress, socket.remotePort)
-  }
+    // 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')
+      }
 
-  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 })
+      remoteAddr = ipPortToMultiaddr(init.socket.remoteAddress, init.socket.remotePort)
     }
 
-    // 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)
-        }
+    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
       }
 
-      // we have finished writing, send the FIN message
-      socket.end()
-    },
+      this.onTransportClosed()
+    })
 
-    source,
+    // the socket can accept more data
+    this.socket.on('drain', () => {
+      this.log('tcp drain')
 
-    // If the remote address was passed, use it - it may have the peer ID encapsulated
-    remoteAddr,
-
-    timeline: { open: Date.now() },
+      this.safeDispatchEvent('drain')
+    })
+  }
 
-    async close (options: AbortOptions = {}) {
-      if (socket.closed) {
-        maConn.log('the %s %s socket is already closed', direction, lOptsStr)
-        return
-      }
+  sendData (data: Uint8ArrayList): SendResult {
+    let sentBytes = 0
+    let canSendMore = true
 
-      if (socket.destroyed) {
-        maConn.log('the %s %s socket is already destroyed', direction, lOptsStr)
-        return
-      }
+    for (const buf of data) {
+      sentBytes += buf.byteLength
+      canSendMore = this.socket.write(buf)
 
-      if (closePromise != null) {
-        return closePromise.promise
+      if (!canSendMore) {
+        break
       }
+    }
 
-      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
-          socket.destroy()
-        ])
-      } catch (err: any) {
-        this.abort(err)
-      } finally {
-        closePromise.resolve()
-      }
-    },
+    return {
+      sentBytes,
+      canSendMore
+    }
+  }
 
-    abort: (err: Error) => {
-      maConn.log('%s %s socket abort due to error - %e', direction, lOptsStr, err)
+  async sendClose (options?: AbortOptions): Promise<void> {
+    if (this.socket.destroyed) {
+      return
+    }
 
-      // the abortSignalListener may already destroyed the socket with an error
-      socket.destroy()
+    this.socket.destroySoon()
 
-      // 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()
-    },
+    await pEvent(this.socket, 'close', options)
+  }
 
-    log: options.logger.forComponent('libp2p:tcp:connection')
+  sendReset (): void {
+    this.socket.resetAndDestroy()
   }
 
-  return maConn
-}
+  sendPause (): void {
+    this.socket.pause()
+  }
 
-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)
-    }
+  sendResume (): void {
+    this.socket.resume()
   }
+}
 
-  // @ts-expect-error partial implementation
-  return eventTarget
+/**
+ * Convert a socket into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export const toMultiaddrConnection = (init: TCPSocketMultiaddrConnectionInit): MultiaddrConnection => {
+  return new TCPSocketMultiaddrConnection(init)
 }

package/src/tcp.ts

@@ -75,6 +75,7 @@ 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)
@@ -82,13 +83,13 @@ export class TCP implements Transport<TCPDialEvents> {
     let maConn: MultiaddrConnection
 
     try {
-      maConn = toMultiaddrConnection(socket, {
-        remoteAddr: ma,
-        socketInactivityTimeout: this.opts.outboundSocketInactivityTimeout,
-        socketCloseTimeout: this.opts.socketCloseTimeout,
+      maConn = toMultiaddrConnection({
+        socket,
+        inactivityTimeout: this.opts.outboundSocketInactivityTimeout,
         metrics: this.metrics?.events,
-        logger: this.components.logger,
-        direction: 'outbound'
+        direction: 'outbound',
+        remoteAddr: ma,
+        log: this.log.newScope('connection')
       })
     } catch (err: any) {
       this.metrics?.errors.increment({ outbound_to_connection: true })
@@ -120,7 +121,7 @@ export class TCP implements Transport<TCPDialEvents> {
         ...options
       }) as (IpcSocketConnectOpts & TcpSocketConnectOpts)
 
-      this.log('dialing %a', ma)
+      this.log('dialing %a with opts %o', ma, cOpts)
       rawSocket = net.connect(cOpts)
 
       const onError = (err: Error): void => {
@@ -192,8 +193,7 @@ export class TCP implements Transport<TCPDialEvents> {
       maxConnections: this.opts.maxConnections,
       backlog: this.opts.backlog,
       closeServerOnMaxConnections: this.opts.closeServerOnMaxConnections,
-      socketInactivityTimeout: this.opts.inboundSocketInactivityTimeout,
-      socketCloseTimeout: this.opts.socketCloseTimeout,
+      inactivityTimeout: this.opts.inboundSocketInactivityTimeout,
       metrics: this.components.metrics,
       logger: this.components.logger
     })

package/src/utils.ts

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