path: normalize windows namespaced paths and add regressions

Author: jazelly

src/path.cc

@@ -98,23 +98,65 @@ constexpr bool IsWindowsDeviceRoot(const char c) noexcept {
   return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
 }
 
-// Strip Windows extended-length path prefix (\\?\) only when it wraps a
-// drive letter path (\\?\C:\...) or a UNC path (\\?\UNC\...).
-// Device paths like \\?\PHYSICALDRIVE0 are left unchanged.
-// See: https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file
-static void StripExtendedPathPrefix(std::string& path) {
-  if (path.size() >= 4 && path[0] == '\\' && path[1] == '\\' &&
-      path[2] == '?' && path[3] == '\\') {
-    if (path.size() >= 6 && IsWindowsDeviceRoot(path[4]) && path[5] == ':') {
+enum class WindowsNamespacedPathType {
+  kNotNamespaced,
+  kDriveAbsolutePath,
+  kUNCPath,
+  kOtherNamespacedPath,
+};
+
+static WindowsNamespacedPathType ClassifyWindowsNamespacedPath(
+    std::string_view path) {
+  if (!(path.size() >= 4 && path[0] == '\\' && path[1] == '\\' &&
+        path[2] == '?' && path[3] == '\\')) {
+    return WindowsNamespacedPathType::kNotNamespaced;
+  }
+
+  if (path.size() >= 7 && IsWindowsDeviceRoot(path[4]) && path[5] == ':' &&
+      IsPathSeparator(path[6])) {
+    return WindowsNamespacedPathType::kDriveAbsolutePath;
+  }
+
+  if (path.size() >= 8 && ToLower(path[4]) == 'u' &&
+      ToLower(path[5]) == 'n' && ToLower(path[6]) == 'c' &&
+      path[7] == '\\') {
+    size_t i = 8;
+    const size_t server_start = i;
+    while (i < path.size() && !IsPathSeparator(path[i])) {
+      i++;
+    }
+    if (i == server_start || i == path.size()) {
+      return WindowsNamespacedPathType::kOtherNamespacedPath;
+    }
+
+    while (i < path.size() && IsPathSeparator(path[i])) {
+      i++;
+    }
+    const size_t share_start = i;
+    while (i < path.size() && !IsPathSeparator(path[i])) {
+      i++;
+    }
+    if (i == share_start) {
+      return WindowsNamespacedPathType::kOtherNamespacedPath;
+    }
+
+    return WindowsNamespacedPathType::kUNCPath;
+  }
+
+  return WindowsNamespacedPathType::kOtherNamespacedPath;
+}
+
+static void StripExtendedPathPrefixForPathResolve(std::string& path) {
+  switch (ClassifyWindowsNamespacedPath(path)) {
+    case WindowsNamespacedPathType::kDriveAbsolutePath:
       path = path.substr(4);
       return;
-    }
-    if (path.size() >= 8 && ToLower(path[4]) == 'u' &&
-        ToLower(path[5]) == 'n' && ToLower(path[6]) == 'c' &&
-        path[7] == '\\') {
+    case WindowsNamespacedPathType::kUNCPath:
       path = "\\\\" + path.substr(8);
       return;
-    }
+    case WindowsNamespacedPathType::kNotNamespaced:
+    case WindowsNamespacedPathType::kOtherNamespacedPath:
+      return;
   }
 }
 
@@ -152,9 +194,7 @@ std::string PathResolve(Environment* env,
       }
     }
 
-    // Strip extended-length path prefix (\\?\C:\... -> C:\...,
-    // \\?\UNC\... -> \\...) before processing.
-    StripExtendedPathPrefix(path);
+    StripExtendedPathPrefixForPathResolve(path);
 
     const size_t len = path.length();
     int rootEnd = 0;
@@ -354,11 +394,16 @@ void ToNamespacedPath(Environment* env, BufferValue* path) {
 // namespace-prefixed path.
 void FromNamespacedPath(std::string* path) {
 #ifdef _WIN32
-  if (path->starts_with("\\\\?\\UNC\\")) {
-    *path = path->substr(8);
-    path->insert(0, "\\\\");
-  } else if (path->starts_with("\\\\?\\")) {
-    *path = path->substr(4);
+  switch (ClassifyWindowsNamespacedPath(*path)) {
+    case WindowsNamespacedPathType::kUNCPath:
+      *path = "\\\\" + path->substr(8);
+      return;
+    case WindowsNamespacedPathType::kDriveAbsolutePath:
+      *path = path->substr(4);
+      return;
+    case WindowsNamespacedPathType::kNotNamespaced:
+    case WindowsNamespacedPathType::kOtherNamespacedPath:
+      return;
   }
 #endif
 }

test/cctest/test_path.cc

@@ -8,6 +8,7 @@
 #include "v8.h"
 
 using node::BufferValue;
+using node::FromNamespacedPath;
 using node::PathResolve;
 using node::ToNamespacedPath;
 
@@ -49,6 +50,7 @@ TEST_F(PathTest, PathResolve) {
             "\\\\server\\share\\");
   EXPECT_EQ(PathResolve(*env, {"\\\\?\\UNC\\server\\share\\dir"}),
             "\\\\server\\share\\dir");
+  EXPECT_EQ(PathResolve(*env, {"\\\\?\\C:foo"}), "\\\\?\\C:foo");
 #else
   EXPECT_EQ(PathResolve(*env, {"/var/lib", "../", "file/"}), "/var/file");
   EXPECT_EQ(PathResolve(*env, {"/var/lib", "/../", "file/"}), "/file");
@@ -104,3 +106,23 @@ TEST_F(PathTest, ToNamespacedPath) {
   EXPECT_EQ(data.ToStringView(), "hello world");  // Input should not be mutated
 #endif
 }
+
+TEST_F(PathTest, FromNamespacedPath) {
+#ifdef _WIN32
+  std::string drive_absolute = "\\\\?\\C:\\foo";
+  FromNamespacedPath(&drive_absolute);
+  EXPECT_EQ(drive_absolute, "C:\\foo");
+
+  std::string unc_absolute = "\\\\?\\UNC\\server\\share\\dir";
+  FromNamespacedPath(&unc_absolute);
+  EXPECT_EQ(unc_absolute, "\\\\server\\share\\dir");
+
+  std::string device_path = "\\\\?\\PHYSICALDRIVE0";
+  FromNamespacedPath(&device_path);
+  EXPECT_EQ(device_path, "\\\\?\\PHYSICALDRIVE0");
+
+  std::string drive_relative = "\\\\?\\C:foo";
+  FromNamespacedPath(&drive_relative);
+  EXPECT_EQ(drive_relative, "\\\\?\\C:foo");
+#endif
+}

test/parallel/test-compile-cache-namespaced-path-win.js

@@ -0,0 +1,62 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works with a Windows namespaced path.
+
+const common = require('../common');
+if (!common.isWindows) {
+  common.skip('this test is Windows-specific.');
+}
+
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+const path = require('path');
+
+{
+  tmpdir.refresh();
+  const cacheDir = tmpdir.resolve('.compile_cache_dir');
+  const namespacedCacheDir = path.toNamespacedPath(cacheDir);
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [fixtures.path('empty.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: namespacedCacheDir,
+      },
+      cwd: tmpdir.path,
+    },
+    {
+      stderr(output) {
+        assert.match(output, /writing cache for .*empty\.js.*success/);
+        return true;
+      },
+    });
+
+  const topEntries = fs.readdirSync(cacheDir);
+  assert.strictEqual(topEntries.length, 1);
+  const cacheEntries = fs.readdirSync(path.join(cacheDir, topEntries[0]));
+  assert.strictEqual(cacheEntries.length, 1);
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [fixtures.path('empty.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: namespacedCacheDir,
+      },
+      cwd: tmpdir.path,
+    },
+    {
+      stderr(output) {
+        assert.match(output, /cache for .*empty\.js was accepted/);
+        return true;
+      },
+    });
+}