feat(net,dgram): add UDP support and fix Windows CI

- Implements dgram.setTOS/getTOS
- Fixes implicit bind edge cases
- Adds Windows ENOSYS guards
- Fixes Dual-Stack priority logic

Author: MaheshThakur9152

lib/dgram.js

@@ -74,13 +74,16 @@ const {
 } = require('internal/async_hooks');
 const { FastBuffer } = require('internal/buffer');
 const { UV_UDP_REUSEADDR } = internalBinding('constants').os;
+const { UV_EBADF, UV_EINVAL } = internalBinding('uv');
 
 const {
   constants: { UV_UDP_IPV6ONLY, UV_UDP_REUSEPORT },
   UDP,
   SendWrap,
 } = internalBinding('udp_wrap');
 
+const kSetTOS = Symbol('kSetTOS');
+
 const dc = require('diagnostics_channel');
 const udpSocketChannel = dc.channel('udp.socket');
 
@@ -201,6 +204,15 @@ function startListening(socket) {
   state.receiving = true;
   state.bindState = BIND_STATE_BOUND;
 
+  // Apply pending TOS if any now that the socket is bound.
+  if (socket[kSetTOS] !== undefined && state.handle && state.handle.setTOS) {
+    const err = state.handle.setTOS(socket[kSetTOS]);
+    if (err && err !== UV_EBADF) {
+      // Non-fatal: surface error to the socket
+      socket.emit('error', new ErrnoException(err, 'setTOS'));
+    }
+  }
+
   if (state.recvBufferSize)
     bufferSize(socket, state.recvBufferSize, RECV_BUFFER);
 
@@ -226,6 +238,15 @@ function replaceHandle(self, newHandle) {
   // Replace the existing handle by the handle we got from primary.
   oldHandle.close();
   state.handle = newHandle;
+
+  // Apply pending TOS if any to the new handle (ignore EBADF; defer)
+  if (self[kSetTOS] !== undefined && state.handle && state.handle.setTOS) {
+    const err = state.handle.setTOS(self[kSetTOS]);
+    if (err && err !== UV_EBADF) {
+      // Non-fatal: surface error to the socket
+      self.emit('error', new ErrnoException(err, 'setTOS'));
+    }
+  }
 }
 
 function bufferSize(self, size, buffer) {
@@ -267,6 +288,9 @@ function bindServerHandle(self, options, errCb) {
 Socket.prototype.bind = function(port_, address_ /* , callback */) {
   let port = port_;
 
+  // Pending TOS will be applied after the socket is successfully bound
+  // (in startListening). Attempting to apply before bind can result in EBADF.
+
   healthCheck(this);
   const state = this[kStateSymbol];
 
@@ -860,6 +884,46 @@ Socket.prototype.setTTL = function(ttl) {
 };
 
 
+Socket.prototype.setTOS = function(tos) {
+  validateNumber(tos, 'tos');
+
+  // TOS must be an integer in the range 0..255.
+  if (!Number.isInteger(tos) || tos < 0 || tos > 255) {
+    throw new ErrnoException(UV_EINVAL, 'setTOS');
+  }
+
+  // Remember the pending value so it can be applied on bind/replaceHandle.
+  this[kSetTOS] = tos;
+
+  const state = this[kStateSymbol];
+  // Only attempt to apply now if the socket is already bound.
+  if (state && state.handle && state.bindState === BIND_STATE_BOUND && state.handle.setTOS) {
+    const err = state.handle.setTOS(tos);
+    // Ignore EBADF: on some platforms the underlying fd may not be
+    // fully initialized yet even though a handle exists. In that case
+    // defer applying the setting to when the socket is actually bound
+    // (handled by bind/replaceHandle).
+    if (err && err !== UV_EBADF) throw new ErrnoException(err, 'setTOS');
+  }
+
+  return tos;
+};
+
+Socket.prototype.getTOS = function() {
+  const state = this[kStateSymbol];
+  // If there is a pending value and the socket is not yet bound, return
+  // the pending value instead of calling into the native handle.
+  if (this[kSetTOS] !== undefined && (!state.handle || state.bindState !== BIND_STATE_BOUND)) {
+    return this[kSetTOS];
+  }
+
+  if (!state.handle || !state.handle.getTOS) return undefined;
+  const result = state.handle.getTOS();
+  if (result < 0) throw new ErrnoException(result, 'getTOS');
+  return result;
+};
+
+
 Socket.prototype.setMulticastTTL = function(ttl) {
   validateNumber(ttl, 'ttl');
 

lib/net.js

@@ -54,13 +54,15 @@ const {
   normalizedArgsSymbol,
   makeSyncWrite,
 } = require('internal/net');
+
 const assert = require('internal/assert');
 const {
   UV_EADDRINUSE,
   UV_EINVAL,
   UV_ENOTCONN,
   UV_ECANCELED,
   UV_ETIMEDOUT,
+  UV_EBADF,
 } = internalBinding('uv');
 const { convertIpv6StringToBuffer } = internalBinding('cares_wrap');
 
@@ -474,7 +476,15 @@ function Socket(options) {
   this[kSetNoDelay] = Boolean(options.noDelay);
   this[kSetKeepAlive] = Boolean(options.keepAlive);
   this[kSetKeepAliveInitialDelay] = ~~(options.keepAliveInitialDelay / 1000);
-  this[kSetTOS] = options.TOS;
+  // Optional initial TOS hint (0 - 255)
+  if (options.tos !== undefined) {
+    validateNumber(options.tos, 'options.tos');
+    if (!Number.isInteger(options.tos) || options.tos < 0 || options.tos > 255)
+      throw new ERR_INVALID_ARG_VALUE('options.tos', options.tos);
+    this[kSetTOS] = options.tos;
+  } else {
+    this[kSetTOS] = undefined;
+  }
 
   // Shut down the socket when we're finished with it.
   this.on('end', onReadableStreamEnd);
@@ -487,6 +497,10 @@ function Socket(options) {
   // If we have a handle, then start the flow of data into the
   // buffer.  if not, then this will happen when we connect
   if (this._handle && options.readable !== false) {
+    // Apply pending TOS if present and supported by the handle
+    if (this[kSetTOS] !== undefined && this._handle.setTOS)
+      this._handle.setTOS(this[kSetTOS]);
+
     if (options.pauseOnCreate) {
       // Stop the handle from reading and pause the stream
       this._handle.reading = false;
@@ -655,43 +669,38 @@ Socket.prototype.setKeepAlive = function(enable, initialDelayMsecs) {
 
 
 Socket.prototype.setTOS = function(tos) {
-  if (NumberIsNaN(tos)) {
-    throw new ERR_INVALID_ARG_TYPE('tos', 'number', tos);
+  validateNumber(tos, 'tos');
+
+  // TOS must be an integer in the range 0..255.
+  if (!Number.isInteger(tos) || tos < 0 || tos > 255) {
+    throw new ErrnoException(UV_EINVAL, 'setTOS');
   }
-  validateInt32(tos, 'tos', 0, 255);
 
   if (!this._handle) {
     this[kSetTOS] = tos;
     return this;
   }
 
-  if (this._handle.setTOS && tos !== this[kSetTOS]) {
+  if (!this._handle.setTOS) {
+    // Handle doesn't support TOS; no-op and remember value
     this[kSetTOS] = tos;
-    const err = this._handle.setTOS(tos);
-    if (err) {
-      throw new ErrnoException(err, 'setTOS');
-    }
+    return this;
   }
 
+  const err = this._handle.setTOS(tos);
+  // Ignore EBADF: transient fd-not-ready states are possible; defer to
+  // after connect when the fd is guaranteed to be ready.
+  if (err && err !== UV_EBADF) throw new ErrnoException(err, 'setTOS');
+  this[kSetTOS] = tos;
   return this;
 };
 
-
 Socket.prototype.getTOS = function() {
-  if (!this._handle) {
-    // Return cached value if set, otherwise default to 0
-    return this[kSetTOS] !== undefined ? this[kSetTOS] : 0;
-  }
-
-  if (!this._handle.getTOS) {
-    return this[kSetTOS];
-  }
-
-  const res = this._handle.getTOS();
-  if (typeof res === 'number' && res < 0) {
-    throw new ErrnoException(res, 'getTOS');
-  }
-  return res;
+  if (!this._handle) throw new ERR_SOCKET_CLOSED();
+  if (!this._handle.getTOS) return undefined;
+  const r = this._handle.getTOS();
+  if (r < 0) throw new ErrnoException(r, 'getTOS');
+  return r;
 };
 
 
@@ -1663,7 +1672,12 @@ function afterConnect(status, handle, req, readable, writable) {
     }
 
     if (self[kSetTOS] !== undefined && self._handle.setTOS) {
-      self._handle.setTOS(self[kSetTOS]);
+      const err = self._handle.setTOS(self[kSetTOS]);
+      if (err && err !== UV_EBADF) {
+        // Non-fatal: surface as an 'error' event to avoid throwing during
+        // connect callbacks
+        self.emit('error', new ErrnoException(err, 'setTOS'));
+      }
     }
 
     self.emit('connect');