fs: implement copyFileSync in C++

Move path validation, file URL conversion, NUL checks, mode
validation, permission checks, and the copy into a dedicated
C++ binding so fs.copyFileSync() no longer goes through
getValidatedPath() in JavaScript.

VFS dispatch stays in JS and still runs before validation.
The copy itself uses uv_fs_copyfile, so flags, mode/timestamp
preservation, and UV error shapes stay the same.

Also fix FileURLToPath aborting on file URLs with a hostname
because the ERR_INVALID_FILE_URL_HOST format string lacked %s.

Signed-off-by: Yagiz Nizipli <yagiz@nizipli.com>

Author: anonrig

lib/fs.js

@@ -3682,11 +3682,7 @@ function copyFileSync(src, dest, mode) {
     const result = h.copyFileSync(src, dest, mode);
     if (result !== undefined) return;
   }
-  binding.copyFile(
-    getValidatedPath(src, 'src'),
-    getValidatedPath(dest, 'dest'),
-    mode,
-  );
+  binding.copyFileSync(src, dest, mode);
 }
 
 /**

src/node_file.cc

@@ -46,6 +46,7 @@
 #include <errno.h>
 #include <cerrno>
 #include <cstdio>
+#include <cstring>
 #include <filesystem>
 
 #if defined(__MINGW32__) || defined(_MSC_VER)
@@ -77,6 +78,7 @@ using v8::Local;
 using v8::LocalVector;
 using v8::Maybe;
 using v8::MaybeLocal;
+using v8::NewStringType;
 using v8::Nothing;
 using v8::Number;
 using v8::Object;
@@ -2416,6 +2418,184 @@ static void OpenFileHandle(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+// Matches lib/internal/url.js isURL(): duck-type WHATWG URL objects vs
+// legacy url.parse() results (which have `auth` and `path` properties).
+static bool IsUrlLike(Environment* env, Local<Value> value) {
+  if (!value->IsObject() || value->IsUint8Array()) {
+    return false;
+  }
+
+  Isolate* isolate = env->isolate();
+  Local<Context> context = env->context();
+  Local<Object> obj = value.As<Object>();
+
+  Local<Value> href;
+  if (!obj->Get(context, env->href_string()).ToLocal(&href)) {
+    return false;
+  }
+  if (!href->BooleanValue(isolate)) {
+    return false;
+  }
+
+  Local<Value> protocol;
+  if (!obj->Get(context, env->protocol_string()).ToLocal(&protocol)) {
+    return false;
+  }
+  if (!protocol->BooleanValue(isolate)) {
+    return false;
+  }
+
+  Local<Value> auth;
+  if (!obj->Get(context, FIXED_ONE_BYTE_STRING(isolate, "auth"))
+           .ToLocal(&auth)) {
+    return false;
+  }
+
+  Local<Value> path;
+  if (!obj->Get(context, env->path_string()).ToLocal(&path)) {
+    return false;
+  }
+
+  return auth->IsUndefined() && path->IsUndefined();
+}
+
+static bool ContainsNul(const BufferValue& path) {
+  return path.length() > 0 &&
+         std::memchr(path.out(), '\0', path.length()) != nullptr;
+}
+
+// C++ equivalent of getValidatedPath(value, propName): accepts string,
+// Uint8Array/Buffer, or WHATWG URL, rejects embedded NUL bytes, and converts
+// file: URLs to paths. Returns an empty MaybeLocal and throws on failure.
+static MaybeLocal<Value> GetValidatedPath(Environment* env,
+                                          Local<Value> input,
+                                          const char* prop_name) {
+  Isolate* isolate = env->isolate();
+
+  if (input->IsString() || input->IsUint8Array()) {
+    return input;
+  }
+
+  if (IsUrlLike(env, input)) {
+    Local<Context> context = env->context();
+    Local<Value> href;
+    if (!input.As<Object>()->Get(context, env->href_string()).ToLocal(&href)) {
+      return MaybeLocal<Value>();
+    }
+
+    Utf8Value href_utf8(isolate, href);
+    auto parsed = ada::parse<ada::url_aggregator>(href_utf8.ToStringView());
+    if (!parsed) {
+      url::ThrowInvalidURL(env, href_utf8.ToStringView(), std::nullopt);
+      return MaybeLocal<Value>();
+    }
+
+    // Match lib/internal/url.js fileURLToPath(): non-file schemes throw
+    // ERR_INVALID_URL_SCHEME with the same message as JS (`file`, not `file:`).
+    if (parsed->type != ada::scheme::FILE) {
+      THROW_ERR_INVALID_URL_SCHEME(isolate, "The URL must be of scheme file");
+      return MaybeLocal<Value>();
+    }
+
+    std::optional<std::string> file_path = url::FileURLToPath(env, *parsed);
+    if (!file_path.has_value()) {
+      return MaybeLocal<Value>();
+    }
+
+    if (file_path->find('\0') != std::string::npos) {
+      THROW_ERR_INVALID_ARG_VALUE(
+          env,
+          "The argument '%s' must be a string, Uint8Array, or URL "
+          "without null bytes. Received %s",
+          prop_name,
+          DetermineSpecificErrorType(env, input));
+      return MaybeLocal<Value>();
+    }
+
+    Local<String> path_string;
+    if (!String::NewFromUtf8(isolate,
+                             file_path->data(),
+                             NewStringType::kNormal,
+                             static_cast<int>(file_path->size()))
+             .ToLocal(&path_string)) {
+      return MaybeLocal<Value>();
+    }
+    return path_string;
+  }
+
+  if (isolate->HasPendingException()) {
+    return MaybeLocal<Value>();
+  }
+
+  THROW_ERR_INVALID_ARG_TYPE(
+      env,
+      "The \"%s\" argument must be of type string or an instance of "
+      "Buffer or URL. Received %s",
+      prop_name,
+      DetermineSpecificErrorType(env, input));
+  return MaybeLocal<Value>();
+}
+
+// Full C++ implementation of fs.copyFileSync(): path validation, mode
+// validation, permission checks, and the copy itself.
+static void CopyFileSync(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+
+  CHECK_GE(args.Length(), 2);  // src, dest[, mode]
+
+  Local<Value> src_val;
+  if (!GetValidatedPath(env, args[0], "src").ToLocal(&src_val)) {
+    return;
+  }
+  Local<Value> dest_val;
+  if (!GetValidatedPath(env, args[1], "dest").ToLocal(&dest_val)) {
+    return;
+  }
+
+  BufferValue src(isolate, src_val);
+  CHECK_NOT_NULL(*src);
+  if (ContainsNul(src)) {
+    THROW_ERR_INVALID_ARG_VALUE(
+        env,
+        "The argument 'src' must be a string, Uint8Array, or URL "
+        "without null bytes. Received %s",
+        DetermineSpecificErrorType(env, args[0]));
+    return;
+  }
+
+  BufferValue dest(isolate, dest_val);
+  CHECK_NOT_NULL(*dest);
+  if (ContainsNul(dest)) {
+    THROW_ERR_INVALID_ARG_VALUE(
+        env,
+        "The argument 'dest' must be a string, Uint8Array, or URL "
+        "without null bytes. Received %s",
+        DetermineSpecificErrorType(env, args[1]));
+    return;
+  }
+
+  Local<Value> mode = args.Length() > 2 ? args[2] : Undefined(isolate);
+  int flags;
+  if (!GetValidFileMode(env, mode, UV_FS_COPYFILE).To(&flags)) {
+    return;
+  }
+
+  ToNamespacedPath(env, &src);
+  ToNamespacedPath(env, &dest);
+
+  THROW_IF_INSUFFICIENT_PERMISSIONS(
+      env, permission::PermissionScope::kFileSystemRead, src.ToStringView());
+  THROW_IF_INSUFFICIENT_PERMISSIONS(
+      env, permission::PermissionScope::kFileSystemWrite, dest.ToStringView());
+
+  FSReqWrapSync req_wrap_sync("copyfile", *src, *dest);
+  FS_SYNC_TRACE_BEGIN(copyfile);
+  SyncCallAndThrowOnError(
+      env, &req_wrap_sync, uv_fs_copyfile, *src, *dest, flags);
+  FS_SYNC_TRACE_END(copyfile);
+}
+
 static void CopyFile(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
@@ -4229,6 +4409,7 @@ static void CreatePerIsolateProperties(IsolateData* isolate_data,
   SetMethod(isolate, target, "writeFileUtf8", WriteFileUtf8);
   SetMethod(isolate, target, "realpath", RealPath);
   SetMethod(isolate, target, "copyFile", CopyFile);
+  SetMethod(isolate, target, "copyFileSync", CopyFileSync);
 
   SetMethod(isolate, target, "chmod", Chmod);
   SetMethod(isolate, target, "fchmod", FChmod);
@@ -4357,6 +4538,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(WriteFileUtf8);
   registry->Register(RealPath);
   registry->Register(CopyFile);
+  registry->Register(CopyFileSync);
 
   registry->Register(CpSyncCheckPaths);
   registry->Register(CpSyncOverrideFile);

src/node_url.cc

@@ -688,7 +688,7 @@ std::optional<std::string> FileURLToPath(Environment* env,
   if (hostname.size() > 0) {
     THROW_ERR_INVALID_FILE_URL_HOST(
         env->isolate(),
-        "File URL host must be \"localhost\" or empty on ",
+        "File URL host must be \"localhost\" or empty on %s",
         std::string(per_process::metadata.platform));
     return std::nullopt;
   }

test/parallel/test-fs-copyfile.js

@@ -10,6 +10,7 @@ const {
   UV_ENOENT,
   UV_EEXIST
 } = internalBinding('uv');
+const { pathToFileURL } = require('url');
 const src = fixtures.path('a.js');
 const dest = tmpdir.resolve('copyfile.out');
 const {
@@ -55,6 +56,22 @@ verify(src, dest);
 fs.copyFileSync(src, dest, 0);
 verify(src, dest);
 
+// Verify Buffer and file: URL paths.
+{
+  const destBuf = tmpdir.resolve('copyfile.buffer');
+  fs.copyFileSync(Buffer.from(src), Buffer.from(destBuf));
+  verify(src, destBuf);
+
+  const destUrl = tmpdir.resolve('copyfile.url');
+  fs.copyFileSync(pathToFileURL(src), pathToFileURL(destUrl));
+  verify(src, destUrl);
+
+  const destU8 = tmpdir.resolve('copyfile.uint8');
+  fs.copyFileSync(new Uint8Array(Buffer.from(src)),
+                  new Uint8Array(Buffer.from(destU8)));
+  verify(src, destU8);
+}
+
 // Verify that UV_FS_COPYFILE_FICLONE can be used.
 fs.unlinkSync(dest);
 fs.copyFileSync(src, dest, UV_FS_COPYFILE_FICLONE);
@@ -142,6 +159,43 @@ assert.throws(() => {
   );
 });
 
+assert.throws(() => {
+  fs.copyFileSync(new URL('http://example.com/a'), dest);
+}, {
+  code: 'ERR_INVALID_URL_SCHEME',
+  name: 'TypeError',
+  message: 'The URL must be of scheme file',
+});
+
+if (common.isWindows) {
+  ['%2f', '%2F', '%5c', '%5C'].forEach((i) => {
+    assert.throws(
+      () => fs.copyFileSync(new URL(`file:///c:/tmp/${i}`), dest),
+      {
+        code: 'ERR_INVALID_FILE_URL_PATH',
+        name: 'TypeError',
+      }
+    );
+  });
+} else {
+  ['%2f', '%2F'].forEach((i) => {
+    assert.throws(
+      () => fs.copyFileSync(new URL(`file:///c:/tmp/${i}`), dest),
+      {
+        code: 'ERR_INVALID_FILE_URL_PATH',
+        name: 'TypeError',
+      }
+    );
+  });
+  assert.throws(
+    () => fs.copyFileSync(new URL('file://hostname/a/b/c'), dest),
+    {
+      code: 'ERR_INVALID_FILE_URL_HOST',
+      name: 'TypeError',
+    }
+  );
+}
+
 assert.throws(() => {
   fs.copyFileSync(src, dest, 'r');
 }, {

typings/internalBinding/fs.d.ts

@@ -75,6 +75,7 @@ declare namespace InternalFSBinding {
   function copyFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, req: FSReqCallback): void;
   function copyFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, req: undefined, ctx: FSSyncContext): void;
   function copyFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, usePromises: typeof kUsePromises): Promise<void>;
+  function copyFileSync(src: unknown, dest: unknown, mode?: unknown): void;
 
   function cpSyncCheckPaths(src: StringOrBuffer, dest: StringOrBuffer, dereference: boolean, recursive: boolean): void;
   function cpSyncOverrideFile(src: StringOrBuffer, dest: StringOrBuffer, mode: number, preserveTimestamps: boolean): void;
@@ -261,6 +262,7 @@ export interface FsBinding {
   chown: typeof InternalFSBinding.chown;
   close: typeof InternalFSBinding.close;
   copyFile: typeof InternalFSBinding.copyFile;
+  copyFileSync: typeof InternalFSBinding.copyFileSync;
   cpSyncCheckPaths: typeof InternalFSBinding.cpSyncCheckPaths;
   cpSyncOverrideFile: typeof InternalFSBinding.cpSyncOverrideFile;
   cpSyncCopyDir: typeof InternalFSBinding.cpSyncCopyDir;