@photostructure/fs-metadata 0.4.0 → 0.5.0

package/src/windows/drive_status.h

@@ -2,6 +2,7 @@
 
 #pragma once
 #include "../common/debug_log.h"
+#include <atomic>
 #include <memory>
 #include <string>
 #include <vector>
@@ -35,15 +36,15 @@ inline std::string DriveStatusToString(DriveStatus status) {
 class IOOperation {
 private:
   HANDLE completionEvent;
-  DriveStatus result;
+  std::atomic<DriveStatus> result;
   std::string path;
   DWORD threadId;
-  volatile bool shouldTerminate;
+  std::atomic<bool> shouldTerminate;
   HANDLE threadHandle; // Store thread handle as member
 
 public:
   IOOperation()
-      : result(DriveStatus::Unknown), threadId(0), shouldTerminate(false),
+      : result{DriveStatus::Unknown}, threadId(0), shouldTerminate{false},
         threadHandle(NULL) {
     completionEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
   }
@@ -59,12 +60,20 @@ public:
     if (threadHandle) {
       DEBUG_LOG("[IOOperation] Cleaning up thread %lu", threadId);
       // Signal termination
-      shouldTerminate = true;
-
-      // Give thread chance to exit gracefully
-      if (WaitForSingleObject(threadHandle, 100) != WAIT_OBJECT_0) {
-        DEBUG_LOG("[IOOperation] Force terminating thread %lu", threadId);
-        TerminateThread(threadHandle, 1);
+      shouldTerminate.store(true, std::memory_order_release);
+
+      // Wake up thread if it's waiting on something
+      SetEvent(completionEvent);
+
+      // Give thread chance to exit gracefully (increased timeout)
+      DWORD waitResult = WaitForSingleObject(threadHandle, 1000);
+      if (waitResult != WAIT_OBJECT_0) {
+        DEBUG_LOG("[IOOperation] WARNING: Thread %lu did not exit gracefully "
+                  "after 1000ms",
+                  threadId);
+        // NEVER use TerminateThread - it's extremely dangerous
+        // Instead, log the issue and abandon the thread
+        // The thread will eventually exit when the process terminates
       }
 
       CloseHandle(threadHandle);
@@ -81,15 +90,23 @@ public:
 
     DEBUG_LOG("[WorkerThread] Starting search on path: %s", searchPath.c_str());
 
+    // Check if we should terminate before starting work
+    if (self->shouldTerminate.load(std::memory_order_acquire)) {
+      DEBUG_LOG("[WorkerThread] Thread %lu terminating before work",
+                self->threadId);
+      return 0;
+    }
+
     findHandle = FindFirstFileExA(
         searchPath.c_str(), FindExInfoBasic, &findData, FindExSearchNameMatch,
         NULL, FIND_FIRST_EX_LARGE_FETCH | FIND_FIRST_EX_ON_DISK_ENTRIES_ONLY);
 
     if (findHandle == INVALID_HANDLE_VALUE) {
-      self->result = self->MapErrorToDriveStatus(GetLastError());
+      self->result.store(self->MapErrorToDriveStatus(GetLastError()),
+                         std::memory_order_release);
       DEBUG_LOG("[WorkerThread] Search failed with error: %lu", GetLastError());
     } else {
-      self->result = DriveStatus::Healthy;
+      self->result.store(DriveStatus::Healthy, std::memory_order_release);
       FindClose(findHandle);
       DEBUG_LOG("[WorkerThread] Search completed successfully");
     }
@@ -109,7 +126,7 @@ public:
 
     path = checkPath;
     ResetEvent(completionEvent);
-    shouldTerminate = false;
+    shouldTerminate.store(false, std::memory_order_release);
 
     threadHandle = CreateThread(NULL, 0, WorkerThread, this, 0, &threadId);
     if (!threadHandle) {
@@ -131,7 +148,7 @@ public:
     CloseHandle(threadHandle);
     DEBUG_LOG("[CheckDriveStatus] CloseHandle %lu completed", threadId);
     threadHandle = NULL;
-    return result;
+    return result.load(std::memory_order_acquire);
   }
 
 private:

package/src/windows/hidden.cpp

@@ -70,6 +70,12 @@ public:
 
   void Execute() override {
     try {
+      // Add path validation to prevent directory traversal
+      if (path.find("..") != std::string::npos) {
+        throw FSException("Invalid path containing '..'",
+                          ERROR_INVALID_PARAMETER);
+      }
+
       auto wpath = PathConverter::ToWString(path);
       FileAttributeHandler handler(wpath);
       result = handler.isHidden();
@@ -98,6 +104,12 @@ public:
 
   void Execute() override {
     try {
+      // Add path validation to prevent directory traversal
+      if (path.find("..") != std::string::npos) {
+        throw FSException("Invalid path containing '..'",
+                          ERROR_INVALID_PARAMETER);
+      }
+
       auto wpath = PathConverter::ToWString(path);
       FileAttributeHandler handler(wpath);
       handler.setHidden(value);

package/src/windows/volume_metadata.cpp

@@ -24,11 +24,20 @@ class WNetConnection {
 
 public:
   explicit WNetConnection(const std::string &path)
-      : drivePath(path.substr(0, 2)), bufferSize(BUFFER_SIZE),
-        buffer(std::make_unique<char[]>(BUFFER_SIZE)) {
+      : drivePath(path.substr(0, 2)), bufferSize(MAX_PATH) {
+
+    // Allocate initial buffer
+    buffer = std::make_unique<char[]>(bufferSize);
 
     DWORD result =
         WNetGetConnectionA(drivePath.c_str(), buffer.get(), &bufferSize);
+
+    if (result == ERROR_MORE_DATA) {
+      // bufferSize now contains the required size
+      buffer = std::make_unique<char[]>(bufferSize);
+      result = WNetGetConnectionA(drivePath.c_str(), buffer.get(), &bufferSize);
+    }
+
     isValid = (result == NO_ERROR);
   }
 
@@ -70,8 +79,9 @@ inline std::string GetVolumeGUID(const std::string &mountPoint) {
 
 // RAII wrapper for volume information
 class VolumeInfo {
-  char volumeName[BUFFER_SIZE];
-  char fstype[BUFFER_SIZE];
+  static constexpr DWORD VOLUME_NAME_SIZE = MAX_PATH + 1; // 261 characters
+  char volumeName[VOLUME_NAME_SIZE];
+  char fstype[VOLUME_NAME_SIZE];
   DWORD serialNumber;
   DWORD maxComponentLen;
   DWORD fsFlags;
@@ -79,9 +89,9 @@ class VolumeInfo {
 
 public:
   explicit VolumeInfo(const std::string &mountPoint) {
-    valid = GetVolumeInformationA(mountPoint.c_str(), volumeName, BUFFER_SIZE,
-                                  &serialNumber, &maxComponentLen, &fsFlags,
-                                  fstype, BUFFER_SIZE);
+    valid = GetVolumeInformationA(
+        mountPoint.c_str(), volumeName, VOLUME_NAME_SIZE, &serialNumber,
+        &maxComponentLen, &fsFlags, fstype, VOLUME_NAME_SIZE);
 
     if (!valid && GetLastError() != ERROR_NOT_READY) {
       throw FSException("GetVolumeInformation", GetLastError());

package/tsup.config.ts

@@ -1,9 +1,15 @@
 import { defineConfig } from "tsup";
 
 export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  dts: true, // Generate .d.ts files automatically
+  clean: true, // Clean dist before each build
+  sourcemap: true,
   outExtension: ({ format }) => ({
     js: format === "cjs" ? ".cjs" : ".mjs", // Use .cjs for CommonJS and .mjs for ESM
   }),
-  shims: true,
-  sourcemap: true,
+  shims: true, // Inject CJS shims (__dirname, __filename) in ESM output
+  target: "es2022", // Align with TypeScript target
+  tsconfig: "tsconfig.build.json", // Use a single tsconfig for building
 });