fs: use bigint for windowsHandle option

Signed-off-by: PickBas <sayed.kirill@gmail.com>

Author: PickBas

doc/api/fs.md

@@ -3003,7 +3003,7 @@ changes:
   * `highWaterMark` {integer} **Default:** `64 * 1024`
   * `fs` {Object|null} **Default:** `null`
   * `signal` {AbortSignal|null} **Default:** `null`
-  * `windowsHandle` {integer} A raw Win32 `HANDLE` value to read from, in place
+  * `windowsHandle` {bigint} A raw Win32 `HANDLE` value to read from, in place
     of `fd`. Windows only. **Default:** `null`
 * Returns: {fs.ReadStream}
 
@@ -3148,7 +3148,7 @@ changes:
     [`stream.getDefaultHighWaterMark()`][].
   * `flush` {boolean} If `true`, the underlying file descriptor is flushed
     prior to closing it. **Default:** `false`.
-  * `windowsHandle` {integer} A raw Win32 `HANDLE` value to write to, in place
+  * `windowsHandle` {bigint} A raw Win32 `HANDLE` value to write to, in place
     of `fd`. Windows only. **Default:** `null`
 * Returns: {fs.WriteStream}
 

lib/internal/fs/streams.js

@@ -23,6 +23,7 @@ const {
   ERR_SYSTEM_ERROR,
 } = require('internal/errors').codes;
 const {
+  isWindows,
   kEmptyObject,
 } = require('internal/util');
 const {
@@ -43,7 +44,6 @@ const {
 } = require('internal/fs/utils');
 const { Readable, Writable, finished } = require('stream');
 const { toPathIfFileURL } = require('internal/url');
-const { isWindows } = require('internal/util');
 const binding = internalBinding('fs');
 const { O_RDONLY, O_WRONLY } = internalBinding('constants').fs;
 const kIoDone = Symbol('kIoDone');
@@ -178,7 +178,10 @@ function importWindowsHandle(stream, options, flags) {
     // implementation cannot be combined with it.
     throw new ERR_METHOD_NOT_IMPLEMENTED('windowsHandle with fs');
   }
-  validateInteger(options.windowsHandle, 'options.windowsHandle');
+  if (typeof options.windowsHandle !== 'bigint') {
+    throw new ERR_INVALID_ARG_TYPE('options.windowsHandle', 'bigint',
+                                   options.windowsHandle);
+  }
   stream[kFs] = fs;
   return binding.handleToFd(options.windowsHandle, flags);
 }

src/node_file.cc

@@ -4154,15 +4154,20 @@ InternalFieldInfoBase* BindingData::Serialize(int index) {
 static void HandleToFd(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK_GE(args.Length(), 1);
-  CHECK(args[0]->IsNumber());
+  CHECK(args[0]->IsBigInt());
 
   int flags = 0;
   if (args[1]->IsNumber()) {
     flags = args[1].As<Int32>()->Value();
   }
 
-  intptr_t value =
-      static_cast<intptr_t>(args[0].As<Number>()->Value());
+  bool lossless;
+  int64_t handle = args[0].As<BigInt>()->Int64Value(&lossless);
+  if (!lossless) {
+    return THROW_ERR_OUT_OF_RANGE(env,
+                                  "windowsHandle does not fit into 64 bits");
+  }
+  intptr_t value = static_cast<intptr_t>(handle);
 
   int fd = _open_osfhandle(value, flags);
   if (fd == -1) {

test/addons/fs-windows-handle/binding.cc

@@ -7,17 +7,17 @@
 
 namespace {
 
+using v8::BigInt;
 using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Isolate;
 using v8::Local;
-using v8::Number;
 using v8::Object;
 using v8::String;
 using v8::Value;
 
 // Creates an anonymous pipe and returns its raw Win32 read/write HANDLE values
-// as JS numbers. These are NOT CRT file descriptors, so passing them as the
+// as JS bigints. These are NOT CRT file descriptors, so passing them as the
 // `windowsHandle` stream option exercises the HANDLE -> fd conversion path on
 // Windows. Returns undefined on other platforms.
 void CreatePipeHandles(const FunctionCallbackInfo<Value>& args) {
@@ -37,16 +37,16 @@ void CreatePipeHandles(const FunctionCallbackInfo<Value>& args) {
   result
       ->Set(context,
             String::NewFromUtf8(isolate, "readHandle").ToLocalChecked(),
-            Number::New(isolate,
-                        static_cast<double>(
-                            reinterpret_cast<intptr_t>(read_handle))))
+            BigInt::New(
+                isolate,
+                static_cast<int64_t>(reinterpret_cast<intptr_t>(read_handle))))
       .Check();
   result
       ->Set(context,
             String::NewFromUtf8(isolate, "writeHandle").ToLocalChecked(),
-            Number::New(isolate,
-                        static_cast<double>(
-                            reinterpret_cast<intptr_t>(write_handle))))
+            BigInt::New(
+                isolate,
+                static_cast<int64_t>(reinterpret_cast<intptr_t>(write_handle))))
       .Check();
   args.GetReturnValue().Set(result);
 #else
@@ -56,9 +56,7 @@ void CreatePipeHandles(const FunctionCallbackInfo<Value>& args) {
 
 }  // anonymous namespace
 
-extern "C" NODE_MODULE_EXPORT void
-NODE_MODULE_INITIALIZER(Local<Object> exports,
-                        Local<Value> module,
-                        Local<Context> context) {
+extern "C" NODE_MODULE_EXPORT void NODE_MODULE_INITIALIZER(
+    Local<Object> exports, Local<Value> module, Local<Context> context) {
   NODE_SET_METHOD(exports, "createPipeHandles", CreatePipeHandles);
 }

test/addons/fs-windows-handle/test.js

@@ -17,8 +17,8 @@ const fs = require('fs');
 const binding = require(`./build/${common.buildType}/binding`);
 
 const { readHandle, writeHandle } = binding.createPipeHandles();
-assert.strictEqual(typeof readHandle, 'number');
-assert.strictEqual(typeof writeHandle, 'number');
+assert.strictEqual(typeof readHandle, 'bigint');
+assert.strictEqual(typeof writeHandle, 'bigint');
 
 const payload = 'payload';
 

test/parallel/test-fs-stream-windows-handle.js

@@ -9,7 +9,7 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 
-const handle = 1;
+const handle = 1n;
 
 for (const create of [fs.createReadStream, fs.createWriteStream]) {
   assert.throws(() => create(null, { windowsHandle: handle, fd: 2 }), {
@@ -32,11 +32,16 @@ for (const create of [fs.createReadStream, fs.createWriteStream]) {
     code: 'ERR_METHOD_NOT_IMPLEMENTED',
   });
 
-  // Must be an integer.
+  // Must be a bigint.
   assert.throws(() => create(null, { windowsHandle: 'nope' }), {
     code: 'ERR_INVALID_ARG_TYPE',
   });
-  assert.throws(() => create(null, { windowsHandle: 1.5 }), {
+  assert.throws(() => create(null, { windowsHandle: 1 }), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+
+  // Must fit into 64 bits.
+  assert.throws(() => create(null, { windowsHandle: 2n ** 64n }), {
     code: 'ERR_OUT_OF_RANGE',
   });
 }