net: support sync connect for BoundSocket

When a net.Socket is constructed from a net.BoundSocket, support
synchronous connect().

Signed-off-by: Guy Bedford <guybedford@gmail.com>
PR-URL: #64375
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: guybedford

doc/api/net.md

@@ -1708,6 +1708,11 @@ Adoption transfers ownership of the socket; afterwards `address()` and `close()`
 throw [`ERR_SOCKET_HANDLE_ADOPTED`][]. A handle that is never adopted must be
 closed to avoid leaking the socket.
 
+When an adopted `BoundSocket` connects to a numeric IP literal, `connect(2)` is
+issued synchronously, so [`socket.localAddress`][] is resolved once
+[`socket.connect()`][] returns. Connection failures are still reported via a
+deferred `'error'` event.
+
 ```mjs
 import net from 'node:net';
 
@@ -2293,6 +2298,7 @@ net.isIPv6('fhqwhgads'); // returns false
 [`socket.connecting`]: #socketconnecting
 [`socket.destroy()`]: #socketdestroyerror
 [`socket.end()`]: #socketenddata-encoding-callback
+[`socket.localAddress`]: #socketlocaladdress
 [`socket.pause()`]: #socketpause
 [`socket.resume()`]: #socketresume
 [`socket.setEncoding()`]: #socketsetencodingencoding

lib/net.js

@@ -1630,6 +1630,17 @@ function lookupAndConnect(self, options) {
   // If host is an IP, skip performing a lookup
   const addressType = isIP(host);
   if (addressType) {
+    // An adopted BoundSocket needs no lookup: issue connect(2) in-tick so the
+    // kernel-resolved concrete source address is observable synchronously.
+    // Connection failures are still reported via a deferred 'error' event.
+    if (self[kBoundSource]) {
+      defaultTriggerAsyncIdScope(
+        self[async_id_symbol],
+        internalConnect,
+        self, host, port, addressType, localAddress, localPort,
+      );
+      return;
+    }
     defaultTriggerAsyncIdScope(self[async_id_symbol], process.nextTick, () => {
       if (self.connecting)
         defaultTriggerAsyncIdScope(

test/parallel/test-net-boundsocket.js

@@ -178,6 +178,42 @@ if (!common.isWindows && process.getuid() !== 0) {
   client.destroy();
 }
 
+// Adopted BoundSocket: connect(2) is synchronous, so localAddress/localPort
+// resolve to the concrete source in-tick, before the 'connect' event.
+{
+  const server = net.createServer();
+  server.listen(0, '127.0.0.1', common.mustCall(() => {
+    const serverPort = server.address().port;
+    const bound = new net.BoundSocket({ host: '127.0.0.1', port: 0 });
+    const localPort = bound.address().port;
+    const client = new net.Socket({ handle: bound });
+
+    client.connect({ host: '127.0.0.1', port: serverPort });
+
+    assert.strictEqual(client.localAddress, '127.0.0.1');
+    assert.strictEqual(client.localPort, localPort);
+
+    client.on('connect', common.mustCall(() => {
+      assert.strictEqual(client.localAddress, '127.0.0.1');
+      assert.strictEqual(client.localPort, localPort);
+      client.destroy();
+      server.close();
+    }));
+  }));
+}
+
+// A connect failure is reported via a deferred 'error' event, never thrown
+// synchronously. An IPv4-bound handle connecting to an IPv6 literal fails on
+// address family mismatch.
+{
+  const bound = new net.BoundSocket({ host: '127.0.0.1', port: 0 });
+  const client = new net.Socket({ handle: bound });
+  client.connect({ host: '::1', port: 1 });
+  client.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.syscall, 'connect');
+  }));
+}
+
 // reusePort: SO_REUSEPORT permits multiple listeners on the same port. Support
 // is platform-dependent, so probe first.
 {