EALREADY when reconnecting socket after destroying immediately after connecting

[everhardt]

Version

v22.10.0

Platform

Darwin xxx.local 23.6.0 Darwin Kernel Version 23.6.0: Mon Jul 29 21:14:21 PDT 2024; root:xnu-10063.141.2~1/RELEASE_ARM64_T8103 arm64

Subsystem

No response

What steps will reproduce the bug?

import { Socket } from 'node:net';

const socket = new Socket();
socket.on('error', (err) => {
  console.log(err);
});
socket.on('connect', () => {
  console.log('connected');
});
socket.connect({ host: 'google.com', port: 80 });
socket.once('close', () => {
  console.log('closed');
  socket.connect({ host: 'google.com', port: 80 });
});
socket.destroy();

How often does it reproduce? Is there a required condition?

Always

What is the expected behavior? Why is that the expected behavior?

Seeing

closed
connected

in the console.

What do you see instead?

closed
Error: connect EALREADY 142.250.179.174:2404 - Local (192.168.178.178:61323)
    at internalConnect (node:net:1097:16)
    at defaultTriggerAsyncIdScope (node:internal/async_hooks:464:18)
    at GetAddrInfoReqWrap.emitLookup [as callback] (node:net:1496:9)
    at GetAddrInfoReqWrap.onlookupall [as oncomplete] (node:dns:132:8) {
  errno: -37,
  code: 'EALREADY',
  syscall: 'connect',
  address: '142.250.179.174',
  port: 2404
}

Additional information

Calling socket.destroySoon(); or socket.end(); does work as intended, but IMO socket.destroy(); should also allow a reconnect immediately afterwards. Note that calling socket.destroy(); on a socket that has been connected does allow for immediate reconnect afterwards as expected.

[jakecastelli]

destroySoon in this case is just an alias of end

node/lib/net.js

Line 797 in cbb72eb

this.end();

IIRC destroy does not gracefully close the socket while end does, see the back trace below:

#0 Socket._final node:net:531:4
#1 prefinish node:internal/streams/writable:914:13
#2 finishMaybe node:internal/streams/writable:928:4
#3 Writable.end node:internal/streams/writable:843:4
#4 Socket.end node:net:735:30

because the socket is still connecting:

if (this.connecting) {
    debug('_final: not yet connected');
    return this.once('connect', () => this._final(cb));
  }

therefore it would gracefully destroy the socket (defer the destroy until connect event is fired).

[everhardt]

destroySoon in this case is just an alias of end

It's more end + destroy I would say?

IIRC destroy does not gracefully close the socket while end does

Absolutely. But normally after calling .destroy and waiting until the 'close' event was emitted you are able to call .connect again. And with normally I mean every situation in which there is more than a few milliseconds (on my system more than 2ms) of difference between .connect and .destroy, irrespective of whether the the connection succeeds or not.

[jakecastelli]

If I am not mistaken, by the time destroy is called, the socket is still connecting (the connect function get a tcp handle from the bindings), therefore you aren't to be able to reuse the connection.

[cedrickah]

@jakecastelli is right. The socket is still connecting. This is why the error with code EALREADY(indicates that the socket already has a pending connection in progress.). The documentation.

The simple fix is to check that the socket is connected before destroying it:

const { Socket } = require('node:net');

const socket = new Socket();
socket.on('error', (err) => {
  console.log(err);
});
socket.on('connect', () => {
  console.log('connected');
  socket.destroy();
});
socket.connect({ host: 'google.com', port: 80 });
socket.once('close', () => {
  console.log('closed');
  socket.connect({ host: 'google.com', port: 80 });
});

Result:

connected
closed
connected

[everhardt]

If I am not mistaken, by the time destroy is called, the socket is still connecting (the connect function get a tcp handle from the bindings), therefore you aren't to be able to reuse the connection.

1. I would say that the destroy should kill the connect, as it does when you call destroy a bit later while still connecting. In this example I took a port that is not open, where connecting fails when timing out (after 75 sec on my system):

   const { Socket } = require('node:net');
   
   function now() {
     const [seconds, nanoseconds] = process.hrtime();
     return seconds * 1000 + Math.floor(nanoseconds / 1e6);
   }
   
   const startAt = now();
   
   function at() {
     return now() - startAt;
   }
   
   const socket = new Socket();
   socket.on('error', (err) => {
     console.log(`${at()}: ${err}`);
   });
   socket.on('connect', () => {
     console.log(`${at()}: connected`);
   });
   socket.connect({ host: 'google.com', port: 1024 });
   socket.once('close', () => {
     console.log(`${at()}: closed`);
     socket.connect({ host: 'google.com', port: 1024 });
   });
   setTimeout(() => {
     console.log(`${at()}: destroying`);
     socket.destroy();
   }, 50);

   this will log:

    56: destroying
    65: closed
    75071: Error: connect ETIMEDOUT 142.251.36.46:1024
   

2. Let's say that the destroy should not destroy the connection when it is still connecting. I don't agree to that (see point 1), but for arguments sake. Then I would expect that the 'close' event is only emitted when the connection is actually reusable

The simple fix is to check that the socket is connected before destroying it (..)

The problem with this is that you have to wait until the connection has been established. Take the example in this post: there it takes 75 sec. I'm looking for a procedure to immediately destroy the socket and reuse it afterwards.

[cedrickah]

@everhardt destroy does not gracefully close the socket while end does. Why not use end then? There is no issue when doing this:

const { Socket } = require('node:net');

const socket = new Socket();
socket.on('error', (err) => {
  console.log(err);
});
socket.on('connect', () => {
  console.log('connected');
});
socket.connect({ host: 'google.com', port: 80 });
socket.once('close', () => {
  console.log('closed');
  socket.connect({ host: 'google.com', port: 80 });
});

socket.end();

Result end gracefully close the ongoing connection:

connected
closed
connected

[everhardt]

True, but try the same thing with a port that gives a timeout:

const { Socket } = require('node:net');

function now() {
  const [seconds, nanoseconds] = process.hrtime();
  return seconds * 1000 + Math.floor(nanoseconds / 1e6);
}

const startAt = now();

function at() {
  return now() - startAt;
}

const socket = new Socket();
socket.on('error', (err) => {
  console.log(`${at()}: ${err}`);
});
socket.on('connect', () => {
  console.log(`${at()}: connected`);
});
socket.connect({ host: 'google.com', port: 1024 });
socket.once('close', () => {
  console.log(`${at()}: closed`);
  socket.connect({ host: 'google.com', port: 1024 });
});
socket.end();

The result then is:

75021: Error: connect ETIMEDOUT 142.250.179.142:1024
75026: closed