net: support sync connect for BoundSocket

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {

doc/api/net.md

@@ -1657,6 +1657,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';
 
@@ -2241,6 +2246,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

@@ -1567,6 +1567,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.
 {