bind error fix

Author: guybedford

doc/api/dgram.md

@@ -461,9 +461,12 @@ added: REPLACEME
 
 The synchronous counterpart of [`socket.connect()`][]. For a UDP socket
 `connect(2)` only records the default peer address and is a local, non-blocking
-system call, so the association is performed inline and any error such as
-`ECONNREFUSED` is thrown synchronously rather than reported via the `'error'`
-event:
+system call, so the association is performed inline. Any error raised by the
+call itself (for example `EAFNOSUPPORT` for a mismatched address family) is
+thrown synchronously rather than reported via the `'error'` event. Because
+`connect(2)` does not probe reachability, errors such as `ECONNREFUSED` are
+still surfaced asynchronously on a later send or receive, exactly as for
+[`socket.connect()`][]:
 
 ```js
 const dgram = require('node:dgram');
@@ -477,7 +480,9 @@ If the socket is still unbound it is bound synchronously first. After
 `connectSync()` returns, [`socket.remoteAddress()`][] is valid synchronously
 and the `'connect'` event is emitted on the next tick. Trying to call
 `connectSync()` on an already connected socket throws an
-[`ERR_SOCKET_DGRAM_IS_CONNECTED`][] exception.
+[`ERR_SOCKET_DGRAM_IS_CONNECTED`][] exception, and calling it while an
+asynchronous [`socket.bind()`][] is still in progress throws an
+[`ERR_SOCKET_ALREADY_BOUND`][] exception.
 
 `address` must be a numeric IP literal; `connectSync()` never performs DNS
 resolution (asynchronous name resolution being the only genuinely blocking part
@@ -1090,6 +1095,7 @@ and `udp6` sockets). The bound address and port can be retrieved using
 [RFC 4007]: https://tools.ietf.org/html/rfc4007
 [`'close'`]: #event-close
 [`'message'`]: #event-message
+[`ERR_SOCKET_ALREADY_BOUND`]: errors.md#err_socket_already_bound
 [`ERR_SOCKET_BAD_PORT`]: errors.md#err_socket_bad_port
 [`ERR_SOCKET_BUFFER_SIZE`]: errors.md#err_socket_buffer_size
 [`ERR_SOCKET_DGRAM_IS_CONNECTED`]: errors.md#err_socket_dgram_is_connected

lib/dgram.js

@@ -507,13 +507,10 @@ Socket.prototype.connect = function(port, address, callback) {
   FunctionPrototypeCall(_connect, this, port, address, callback);
 };
 
-// Synchronous counterpart of connect(). For a UDP socket connect(2) only sets
-// the default peer address and is a local, non-blocking operation, so this
-// connects inline and throws synchronously on error. The address must be a
-// numeric IP literal: asynchronous name resolution is the only genuinely
-// blocking part of connect(), so callers resolve names separately. If the
-// socket is still unbound it is bound synchronously first (see bindSync()).
-// The 'connect' event is emitted on the next tick.
+// Synchronous counterpart of connect(). connect(2) on a UDP socket only records
+// the default peer locally, so it runs inline and throws on errors raised by
+// the call itself; unreachable-peer errors stay asynchronous as for connect().
+// The address must be a numeric IP literal since DNS resolution is async.
 Socket.prototype.connectSync = function(port, address) {
   healthCheck(this);
   port = validatePort(port, 'Port', false);
@@ -538,6 +535,8 @@ Socket.prototype.connectSync = function(port, address) {
 
   if (state.bindState === BIND_STATE_UNBOUND)
     this.bindSync();
+  else if (state.bindState !== BIND_STATE_BOUND)
+    throw new ERR_SOCKET_ALREADY_BOUND();
 
   state.connectState = CONNECT_STATE_CONNECTING;
 

test/parallel/test-dgram-connect-sync.js

@@ -2,6 +2,7 @@
 const common = require('../common');
 const assert = require('assert');
 const dgram = require('dgram');
+const net = require('net');
 
 // connectSync() connects synchronously, binding the socket first when needed,
 // and remoteAddress() is valid immediately.
@@ -115,6 +116,29 @@ const dgram = require('dgram');
   sock.close();
 }
 
+// Throws synchronously for a blocked address, leaving the socket reusable.
+{
+  const blockList = new net.BlockList();
+  blockList.addAddress('127.0.0.1');
+  const sock = dgram.createSocket({ type: 'udp4', sendBlockList: blockList });
+  assert.throws(() => sock.connectSync(12345, '127.0.0.1'), {
+    code: 'ERR_IP_BLOCKED',
+  });
+  sock.connectSync(12345, '127.0.0.2');
+  assert.strictEqual(sock.remoteAddress().address, '127.0.0.2');
+  sock.close();
+}
+
+// Throws when an asynchronous bind() is still in progress.
+{
+  const sock = dgram.createSocket('udp4');
+  sock.bind(0, '127.0.0.1');
+  assert.throws(() => sock.connectSync(12345, '127.0.0.1'), {
+    code: 'ERR_SOCKET_ALREADY_BOUND',
+  });
+  sock.on('listening', common.mustCall(() => sock.close()));
+}
+
 // udp6 loopback default.
 if (common.hasIPv6) {
   const sock = dgram.createSocket('udp6');