src: example use of gsl::narrow to uncover a bug

Author: refack

deps/GSL/gsl/gsl_assert

@@ -125,9 +125,15 @@ namespace details
 #if defined(GSL_TERMINATE_ON_CONTRACT_VIOLATION)
 
     template <typename Exception>
-    [[noreturn]] void throw_exception(Exception&&) noexcept
+    [[noreturn]] void throw_exception(Exception&& ex) noexcept
     {
-        gsl::details::terminate();
+      static const char* const args[] = {
+        __FILE__,
+        STRINGIFY(__LINE__),
+        ex.what(),
+        PRETTY_FUNCTION_NAME
+      };
+      node::Assert(&args);
     }
 
 #else

doc/api/fs.md

@@ -638,6 +638,8 @@ The numeric identifier of the device containing the file.
 
 The file system specific "Inode" number for the file.
 
+*Note*: The `number` version is unreliable on Windows as values often overflow.
+
 ### stats.mode
 
 * {number|bigint}

node.gypi

@@ -29,6 +29,7 @@
     'deps/v8/include',
     'src',
   ],
+  'defines': [ 'GSL_TERMINATE_ON_CONTRACT_VIOLATION', ],
   # Putting these explicitly here so not to be dependant on common.gypi.
   'cflags': [ '-Wall', '-Wextra', '-Wno-unused-parameter', ],
   'xcode_settings': {

src/node_file.h

@@ -6,6 +6,7 @@
 #include "node.h"
 #include "stream_base.h"
 #include "req_wrap-inl.h"
+#include <gsl/gsl_util>
 
 namespace node {
 
@@ -193,24 +194,25 @@ constexpr uint64_t ToNative(uv_timespec_t ts) {
 template <typename NativeT, typename V8T>
 constexpr void FillStatsArray(AliasedBuffer<NativeT, V8T>* fields,
                               const uv_stat_t* s, const size_t offset = 0) {
-  fields->SetValue(offset + 0, s->st_dev);
-  fields->SetValue(offset + 1, s->st_mode);
-  fields->SetValue(offset + 2, s->st_nlink);
-  fields->SetValue(offset + 3, s->st_uid);
-  fields->SetValue(offset + 4, s->st_gid);
-  fields->SetValue(offset + 5, s->st_rdev);
+  fields->SetValue(offset + 0, gsl::narrow<NativeT>(s->st_dev));
+  fields->SetValue(offset + 1, gsl::narrow<NativeT>(s->st_mode));
+  fields->SetValue(offset + 2, gsl::narrow<NativeT>(s->st_nlink));
+  fields->SetValue(offset + 3, gsl::narrow<NativeT>(s->st_uid));
+  fields->SetValue(offset + 4, gsl::narrow<NativeT>(s->st_gid));
+  fields->SetValue(offset + 5, gsl::narrow<NativeT>(s->st_rdev));
 #if defined(__POSIX__)
-  fields->SetValue(offset + 6, s->st_blksize);
+  fields->SetValue(offset + 6, gsl::narrow<NativeT>(s->st_blksize));
+  fields->SetValue(offset + 7, gsl::narrow<NativeT>(s->st_ino));
+  fields->SetValue(offset + 8, gsl::narrow<NativeT>(s->st_size));
+  fields->SetValue(offset + 9, gsl::narrow<NativeT>(s->st_blocks));
 #else
   fields->SetValue(offset + 6, 0);
-#endif
-  fields->SetValue(offset + 7, s->st_ino);
-  fields->SetValue(offset + 8, s->st_size);
-#if defined(__POSIX__)
-  fields->SetValue(offset + 9, s->st_blocks);
-#else
+  // This overflows on Windows for NativeT == double
+  fields->SetValue(offset + 7, gsl::narrow_cast<NativeT>(s->st_ino));
+  fields->SetValue(offset + 8, gsl::narrow<NativeT>(s->st_size));
   fields->SetValue(offset + 9, 0);
 #endif
+
 // Dates.
   fields->SetValue(offset + 10, ToNative<NativeT>(s->st_atim));
   fields->SetValue(offset + 11, ToNative<NativeT>(s->st_mtim));

test/known_issues/test-fs-stat-ino-overflow-on-windows.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+if (!common.isWindows)
+  assert.fail('Code should fail only on Windows.');
+
+const fs = require('fs');
+const promiseFs = require('fs').promises;
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+const { isDate } = require('util').types;
+
+tmpdir.refresh();
+
+let testIndex = 0;
+
+function getFilename() {
+  const filename = path.join(tmpdir.path, `test-file-${++testIndex}`);
+  fs.writeFileSync(filename, 'test');
+  return filename;
+}
+
+function verifyStats(bigintStats, numStats) {
+  assert.ok(Number.isSafeInteger(numStats.ino));
+  assert.strictEqual(bigintStats.ino, BigInt(numStats.ino));
+}
+
+{
+  const filename = getFilename();
+  const bigintStats = fs.statSync(filename, { bigint: true });
+  const numStats = fs.statSync(filename);
+  verifyStats(bigintStats, numStats);
+}
+
+{
+  const filename = __filename;
+  const bigintStats = fs.statSync(filename, { bigint: true });
+  const numStats = fs.statSync(filename);
+  verifyStats(bigintStats, numStats);
+}
+
+{
+  const filename = __dirname;
+  const bigintStats = fs.statSync(filename, { bigint: true });
+  const numStats = fs.statSync(filename);
+  verifyStats(bigintStats, numStats);
+}
+
+{
+  const filename = getFilename();
+  const fd = fs.openSync(filename, 'r');
+  const bigintStats = fs.fstatSync(fd, { bigint: true });
+  const numStats = fs.fstatSync(fd);
+  verifyStats(bigintStats, numStats);
+  fs.closeSync(fd);
+}
+
+{
+  const filename = getFilename();
+  fs.stat(filename, { bigint: true }, (err, bigintStats) => {
+    fs.stat(filename, (err, numStats) => {
+      verifyStats(bigintStats, numStats);
+    });
+  });
+}
+
+{
+  const filename = getFilename();
+  const fd = fs.openSync(filename, 'r');
+  fs.fstat(fd, { bigint: true }, (err, bigintStats) => {
+    fs.fstat(fd, (err, numStats) => {
+      verifyStats(bigintStats, numStats);
+      fs.closeSync(fd);
+    });
+  });
+}
+
+(async function() {
+  const filename = getFilename();
+  const bigintStats = await promiseFs.stat(filename, { bigint: true });
+  const numStats = await promiseFs.stat(filename);
+  verifyStats(bigintStats, numStats);
+})();
+
+(async function() {
+  const filename = getFilename();
+  const handle = await promiseFs.open(filename, 'r');
+  const bigintStats = await handle.stat({ bigint: true });
+  const numStats = await handle.stat();
+  verifyStats(bigintStats, numStats);
+  await handle.close();
+})();