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

@@ -1698,6 +1698,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
 importnetfrom'node:net';
 
@@ -2283,6 +2288,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
 constaddressType=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.
+{
+constserver=net.createServer();
+server.listen(0,'127.0.0.1',common.mustCall(()=>{
+constserverPort=server.address().port;
+constbound=newnet.BoundSocket({host: '127.0.0.1',port: 0});
+constlocalPort=bound.address().port;
+constclient=newnet.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.
+{
+constbound=newnet.BoundSocket({host: '127.0.0.1',port: 0});
+constclient=newnet.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.
 {