http: attach error handler to socket synchronously in onSocket

Between onSocket and onSocketNT, the socket had no error handler,
meaning any errors emitted during that window (e.g. from a blocklist
check or custom lookup) would be unhandled even if the user had set up
a request error handler.

Fix this by attaching socketErrorListener synchronously in onSocket,
setting socket._httpMessage so the listener can forward errors to the
request. tickOnSocket removes and re-adds the listener after the parser
is set up to avoid duplicates. The _destroy path in onSocketNT is also
guarded to prevent double-firing if socketErrorListener already emitted
the error.

Fixes: #61658 (comment)

Author: RajeshKumar11

lib/_http_client.js

@@ -571,7 +571,9 @@ function socketErrorListener(err) {
   if (req) {
     // For Safety. Some additional errors might fire later on
     // and we need to make sure we don't double-fire the error event.
-    req.socket._hadError = true;
+    // Use socket directly as req.socket may not be assigned yet (e.g. when
+    // the error is emitted before onSocketNT runs).
+    (req.socket || socket)._hadError = true;
     emitErrorEvent(req, err);
   }
 
@@ -906,6 +908,9 @@ function tickOnSocket(req, socket) {
   parser.joinDuplicateHeaders = req.joinDuplicateHeaders;
 
   parser.onIncoming = parserOnIncomingClient;
+  // Remove the early error listener attached in onSocket (if any) before
+  // re-adding it here to avoid duplicate listeners.
+  socket.removeListener('error', socketErrorListener);
   socket.on('error', socketErrorListener);
   socket.on('data', socketOnData);
   socket.on('end', socketOnEnd);
@@ -945,8 +950,16 @@ function listenSocketTimeout(req) {
 }
 
 ClientRequest.prototype.onSocket = function onSocket(socket, err) {
-  // TODO(ronag): Between here and onSocketNT the socket
-  // has no 'error' handler.
+  // Attach the error listener synchronously so that any errors emitted on
+  // the socket before onSocketNT runs (e.g. from a blocklist check or other
+  // next-tick error) are forwarded to the request and can be caught by the
+  // user's error handler. socketErrorListener requires socket._httpMessage
+  // to be set so we set it here too.  tickOnSocket will re-add these after
+  // the parser is fully set up, so we remove them first to avoid duplicates.
+  if (socket && !err) {
+    socket._httpMessage = this;
+    socket.on('error', socketErrorListener);
+  }
   process.nextTick(onSocketNT, this, socket, err);
 };
 
@@ -958,8 +971,10 @@ function onSocketNT(req, socket, err) {
       if (!req.aborted && !err) {
         err = new ConnResetException('socket hang up');
       }
-      // ERR_PROXY_TUNNEL is handled by the proxying logic
-      if (err && err.code !== 'ERR_PROXY_TUNNEL') {
+      // ERR_PROXY_TUNNEL is handled by the proxying logic.
+      // Skip if the error was already emitted by the early socketErrorListener.
+      if (err && err.code !== 'ERR_PROXY_TUNNEL' &&
+          !(socket && socket._hadError)) {
         emitErrorEvent(req, err);
       }
       req._closed = true;