wip

Author: fraidev

ext/node/ops/fs.rs

@@ -844,13 +844,65 @@ fn dup_fd_impl(state: &mut OpState, fd: i32) -> Result<ResourceId, FsError> {
 #[op2(fast)]
 #[smi]
 pub fn op_node_dup_fd(
-  _state: &mut OpState,
-  #[smi] _fd: i32,
+  state: &mut OpState,
+  #[smi] fd: i32,
 ) -> Result<ResourceId, FsError> {
-  Err(FsError::Io(std::io::Error::new(
-    std::io::ErrorKind::Unsupported,
-    "op_node_dup_fd is not supported on this platform",
-  )))
+  dup_fd_impl(state, fd)
+}
+
+#[cfg(not(unix))]
+fn dup_fd_impl(state: &mut OpState, fd: i32) -> Result<ResourceId, FsError> {
+  use std::fs::File as StdFile;
+  use std::os::windows::io::BorrowedHandle;
+  use std::os::windows::io::RawHandle;
+
+  if fd < 0 {
+    return Err(FsError::Io(std::io::Error::new(
+      std::io::ErrorKind::InvalidInput,
+      "Invalid file descriptor",
+    )));
+  }
+
+  // Convert CRT fd to Windows HANDLE.
+  // get_osfhandle returns -1 for invalid fds, -2 for non-stream fds.
+  let raw_handle = unsafe { libc::get_osfhandle(fd) };
+  if raw_handle == -1 || raw_handle == -2 {
+    // ERROR_INVALID_HANDLE (6) maps to EBADF via uvTranslateSysError
+    return Err(FsError::Io(std::io::Error::from_raw_os_error(6)));
+  }
+  let handle = raw_handle as RawHandle;
+
+  // Check if this handle is managed by a non-fsFile internal Deno resource.
+  // fsFile resources (opened via node:fs) are safe to dup.
+  // Other managed resources (SQLite, internal pipes) are denied.
+  // Unmanaged fds (child_process, native addons) are allowed through.
+  for (rid, name) in state.resource_table.names() {
+    if name == "fsFile" || name == "signal" {
+      continue;
+    }
+    if matches!(
+      state.resource_table.get_handle(rid),
+      Ok(deno_core::ResourceHandle::Fd(existing_handle)) if existing_handle == handle
+    ) {
+      return Err(FsError::Io(std::io::Error::new(
+        std::io::ErrorKind::PermissionDenied,
+        "File descriptor is managed by an internal Deno resource",
+      )));
+    }
+  }
+
+  // Duplicate the handle so it's independently owned and closeable.
+  // SAFETY: handle is valid (checked above via get_osfhandle).
+  let borrowed = unsafe { BorrowedHandle::borrow_raw(handle) };
+  let owned = borrowed.try_clone_to_owned().map_err(FsError::Io)?;
+
+  let std_file = StdFile::from(owned);
+  let file: Rc<dyn deno_io::fs::File> =
+    Rc::new(deno_io::StdFileResourceInner::file(std_file, None));
+  let rid = state
+    .resource_table
+    .add(FileResource::new(file, "fsFile".to_string()));
+  Ok(rid)
 }
 
 #[derive(Debug, Serialize)]