@photostructure/fs-metadata 0.7.1 → 0.8.0

package/src/linux/gio_volume_metadata.cpp

@@ -49,94 +49,22 @@ void addMountMetadata(const std::string &mountPoint, VolumeMetadata &metadata) {
       }
     }
 
-    // OPTIONAL ENHANCEMENT: Try to get rich metadata from GVolumeMonitor
-    // This may fail (thread safety violation), but that's OK - we have basic
-    // data
-    try {
-      GVolumeMonitor *monitor = MountIterator::tryGetMonitor();
-      if (monitor) {
-        DEBUG_LOG(
-            "[gio::addMountMetadata] attempting GVolumeMonitor enrichment");
-
-        // Try to find matching GMount for this path
-        GList *mounts = g_volume_monitor_get_mounts(monitor);
-        if (mounts) {
-          for (GList *l = mounts; l != nullptr; l = l->next) {
-            GMount *mount = G_MOUNT(l->data);
-            if (!mount || !G_IS_MOUNT(mount)) {
-              continue;
-            }
-
-            GFile *root = g_mount_get_root(mount);
-            if (root) {
-              char *path = g_file_get_path(root);
-              if (path && mountPoint == path) {
-                // Found matching mount - try to get rich metadata
-
-                // Try to get volume label
-                if (metadata.label.empty()) {
-                  GVolume *volume = g_mount_get_volume(mount);
-                  if (volume) {
-                    char *label = g_volume_get_name(volume);
-                    if (label) {
-                      DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, "
-                                "label: %s} (from GVolume)",
-                                path, label);
-                      metadata.label = label;
-                      g_free(label);
-                    }
-                    g_object_unref(volume);
-                  }
-                }
-
-                // Try to get mount name
-                if (metadata.mountName.empty()) {
-                  char *mount_name = g_mount_get_name(mount);
-                  if (mount_name) {
-                    metadata.mountName = mount_name;
-                    g_free(mount_name);
-                  }
-                }
-
-                // Try to get URI
-                if (metadata.uri.empty()) {
-                  GFile *location = g_mount_get_default_location(mount);
-                  if (location) {
-                    char *uri = g_file_get_uri(location);
-                    if (uri) {
-                      DEBUG_LOG("[gio::addMountMetadata] {mountPoint: %s, uri: "
-                                "%s} (from GMount)",
-                                path, uri);
-                      metadata.uri = uri;
-                      g_free(uri);
-                    }
-                    g_object_unref(location);
-                  }
-                }
-
-                g_free(path);
-                g_object_unref(root);
-                break; // Found our mount
-              }
-              if (path)
-                g_free(path);
-              g_object_unref(root);
-            }
-          }
-
-          // Clean up mounts list - this time correctly without double-free
-          g_list_free_full(mounts,
-                           reinterpret_cast<GDestroyNotify>(g_object_unref));
-        }
-
-        // Note: Don't unref monitor - it's a singleton
-      }
-    } catch (const std::exception &e) {
-      DEBUG_LOG("[gio::addMountMetadata] GVolumeMonitor enrichment failed "
-                "(expected, not critical): %s",
-                e.what());
-      // Ignore - we have basic metadata from Unix mount API
-    }
+    // NOTE: GVolumeMonitor enrichment has been removed.
+    //
+    // According to GIO documentation:
+    // https://docs.gtk.org/gio/class.VolumeMonitor.html
+    // "GVolumeMonitor is not thread-default-context aware and so should not
+    // be used other than from the main thread, with no thread-default-context
+    // active."
+    //
+    // This function is called from Napi::AsyncWorker::Execute() which runs
+    // on a worker thread. Using GVolumeMonitor here causes race conditions
+    // leading to GLib-GObject-CRITICAL errors like:
+    //   "g_object_ref: assertion '!object_already_finalized' failed"
+    //
+    // The basic metadata (fstype, mountFrom) from g_unix_mounts_get() is
+    // sufficient and thread-safe. Rich metadata (label, mountName, uri) can
+    // be obtained from blkid or other thread-safe sources.
 
     return false; // Stop iteration, we found our mount
   });

package/src/linux/volume_metadata.cpp

@@ -2,12 +2,15 @@
 #include "../common/volume_metadata.h"
 #include "../common/debug_log.h"
 #include "../common/error_utils.h"
+#include "../common/fd_guard.h"
 #include "../common/metadata_worker.h"
+#include "../common/path_security.h"
+#include "../common/volume_utils.h"
 #include "blkid_cache.h"
 #include <fcntl.h> // for open(), O_DIRECTORY, O_RDONLY, O_CLOEXEC
 #include <memory>
 #include <sys/statvfs.h>
-#include <unistd.h> // for close()
+#include <unistd.h>
 
 #ifdef ENABLE_GIO
 #include "gio_volume_metadata.h"
@@ -32,6 +35,18 @@ public:
       DEBUG_LOG("[LinuxMetadataWorker] starting statvfs for %s",
                 mountPoint.c_str());
 
+      // Validate and canonicalize mount point using realpath()
+      // This prevents directory traversal attacks and resolves symlinks
+      std::string error;
+      std::string validated_mount_point =
+          ValidatePathForRead(mountPoint, error);
+      if (validated_mount_point.empty()) {
+        throw FSException(error);
+      }
+
+      DEBUG_LOG("[LinuxMetadataWorker] Using validated mount point: %s",
+                validated_mount_point.c_str());
+
       // SECURITY: Use file descriptor-based approach to prevent TOCTOU race
       // condition
       //
@@ -45,23 +60,18 @@ public:
       // O_DIRECTORY: Ensures we're opening a directory, fails if not
       // O_RDONLY: Read-only access (sufficient for fstatvfs)
       // O_CLOEXEC: Close on exec (prevents fd leaks in multithreaded programs)
-      int fd = open(mountPoint.c_str(), O_DIRECTORY | O_RDONLY | O_CLOEXEC);
+      int fd = open(validated_mount_point.c_str(),
+                    O_DIRECTORY | O_RDONLY | O_CLOEXEC);
       if (fd < 0) {
         int error = errno;
         DEBUG_LOG("[LinuxMetadataWorker] open failed for %s: %s (%d)",
-                  mountPoint.c_str(), strerror(error), error);
-        throw FSException(CreatePathErrorMessage("open", mountPoint, error));
+                  validated_mount_point.c_str(), strerror(error), error);
+        throw FSException(
+            CreatePathErrorMessage("open", validated_mount_point, error));
       }
 
       // RAII guard to ensure file descriptor is always closed
-      struct FdGuard {
-        int fd;
-        ~FdGuard() {
-          if (fd >= 0) {
-            close(fd);
-          }
-        }
-      } fd_guard{fd};
+      FdGuard fd_guard(fd);
 
       // Use fstatvfs on the file descriptor instead of statvfs on the path
       // The fd holds a reference to the filesystem, preventing TOCTOU issues
@@ -69,9 +79,9 @@ public:
       if (fstatvfs(fd, &vfs) != 0) {
         int error = errno;
         DEBUG_LOG("[LinuxMetadataWorker] fstatvfs failed for %s: %s (%d)",
-                  mountPoint.c_str(), strerror(error), error);
+                  validated_mount_point.c_str(), strerror(error), error);
         throw FSException(
-            CreatePathErrorMessage("fstatvfs", mountPoint, error));
+            CreatePathErrorMessage("fstatvfs", validated_mount_point, error));
       }
 
       // fd_guard will automatically close the file descriptor when this
@@ -83,16 +93,14 @@ public:
       const uint64_t freeBlocks = static_cast<uint64_t>(vfs.f_bfree);
 
       // Check for overflow before multiplication
-      if (blockSize > 0) {
-        if (totalBlocks > std::numeric_limits<uint64_t>::max() / blockSize) {
-          throw FSException("Total volume size calculation would overflow");
-        }
-        if (availBlocks > std::numeric_limits<uint64_t>::max() / blockSize) {
-          throw FSException("Available space calculation would overflow");
-        }
-        if (freeBlocks > std::numeric_limits<uint64_t>::max() / blockSize) {
-          throw FSException("Free space calculation would overflow");
-        }
+      if (WouldOverflow(blockSize, totalBlocks)) {
+        throw FSException("Total volume size calculation would overflow");
+      }
+      if (WouldOverflow(blockSize, availBlocks)) {
+        throw FSException("Available space calculation would overflow");
+      }
+      if (WouldOverflow(blockSize, freeBlocks)) {
+        throw FSException("Free space calculation would overflow");
       }
 
       metadata.remote = false;
@@ -108,11 +116,11 @@ public:
 #ifdef ENABLE_GIO
       try {
         DEBUG_LOG("[LinuxMetadataWorker] collecting GIO metadata for %s",
-                  mountPoint.c_str());
-        gio::addMountMetadata(mountPoint, metadata);
+                  validated_mount_point.c_str());
+        gio::addMountMetadata(validated_mount_point, metadata);
       } catch (const std::exception &e) {
         DEBUG_LOG("[LinuxMetadataWorker] GIO error for %s: %s",
-                  mountPoint.c_str(), e.what());
+                  validated_mount_point.c_str(), e.what());
         metadata.status = std::string("GIO warning: ") + e.what();
       }
 #endif

package/src/options.ts

@@ -1,17 +1,30 @@
 // src/options.ts
 
 import { availableParallelism } from "node:os";
+import { env } from "node:process";
 import { compactValues, isObject } from "./object";
 import { isWindows } from "./platform";
 import type { Options } from "./types/options";
 
+const DefaultTimeoutMs = 5_000;
+
 /**
- * Default timeout in milliseconds for {@link Options.timeoutMs}.
+ * Get the default timeout in milliseconds for {@link Options.timeoutMs}.
+ *
+ * This can be overridden by setting the `FS_METADATA_TIMEOUT_MS` environment
+ * variable to a positive integer.
  *
  * Note that this timeout may be insufficient for some devices, like spun-down
  * optical drives or network shares that need to spin up or reconnect.
+ *
+ * @returns The timeout from env var if valid, otherwise 5000ms
  */
-export const TimeoutMsDefault = 5_000 as const;
+export function getTimeoutMsDefault(): number {
+  const value = env["FS_METADATA_TIMEOUT_MS"];
+  if (value == null) return DefaultTimeoutMs;
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DefaultTimeoutMs;
+}
 
 /**
  * System paths and globs that indicate system volumes
@@ -104,7 +117,7 @@ export const SkipNetworkVolumesDefault = false;
  * @see {@link optionsWithDefaults} for creating an options object with default values
  */
 export const OptionsDefault: Options = {
-  timeoutMs: TimeoutMsDefault,
+  timeoutMs: getTimeoutMsDefault(),
   maxConcurrency: availableParallelism(),
   systemPathPatterns: [...SystemPathPatternsDefault],
   systemFsTypes: [...SystemFsTypesDefault],

package/src/types/options.ts

@@ -12,7 +12,7 @@ export interface Options {
    *
    * Disable timeouts by setting this to 0.
    *
-   * @see {@link TimeoutMsDefault}.
+   * @see {@link getTimeoutMsDefault}.
    */
   timeoutMs: number;
 

package/src/windows/drive_status.h

@@ -4,13 +4,9 @@
 #include "security_utils.h"
 #include "thread_pool.h"
 #include "windows_arch.h"
-#include <atomic>
 #include <chrono>
-#include <condition_variable>
 #include <future>
-#include <mutex>
 #include <string>
-#include <thread>
 #include <vector>
 
 namespace FSMeta {
@@ -83,7 +79,10 @@ private:
     searchPath += "*";
 
     WIN32_FIND_DATAA findData;
-    HandleGuard findHandle(FindFirstFileExA(
+    // Use FindHandleGuard - search handles MUST be closed with FindClose,
+    // not CloseHandle. See:
+    // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-findclose
+    FindHandleGuard findHandle(FindFirstFileExA(
         searchPath.c_str(), FindExInfoBasic, &findData, FindExSearchNameMatch,
         nullptr,
         FIND_FIRST_EX_LARGE_FETCH | FIND_FIRST_EX_ON_DISK_ENTRIES_ONLY));
@@ -96,69 +95,77 @@ private:
     }
 
     // Successfully opened - drive is healthy
-    FindClose(findHandle.release());
+    // FindHandleGuard destructor will call FindClose automatically
     DEBUG_LOG("[DriveStatusChecker] Drive %s is healthy", path.c_str());
     return DriveStatus::Healthy;
   }
 
 public:
-  static std::future<DriveStatus> CheckDriveAsync(const std::string &path,
-                                                  DWORD timeoutMs = 5000) {
+  // Submit a drive check to the thread pool and return a future.
+  // The caller is responsible for enforcing timeout via future.wait_for().
+  // This design avoids detached threads and race conditions.
+  static std::future<DriveStatus> CheckDriveAsync(const std::string &path) {
     auto promise = std::make_shared<std::promise<DriveStatus>>();
     auto future = promise->get_future();
 
-    // Use a shared state for timeout handling
-    auto state = std::make_shared<std::atomic<bool>>(false);
-
-    GetGlobalThreadPool().Submit([path, promise, state, timeoutMs]() {
-      // Set up timeout
-      auto startTime = std::chrono::steady_clock::now();
-
-      // Perform the check
-      DriveStatus status = CheckDriveInternal(path);
-
-      // Check if we've timed out
-      auto elapsed = std::chrono::steady_clock::now() - startTime;
-      if (elapsed > std::chrono::milliseconds(timeoutMs)) {
-        status = DriveStatus::Timeout;
-      }
-
-      // Only set the promise if we haven't been cancelled
-      if (!state->load()) {
+    GetGlobalThreadPool().Submit([path, promise]() {
+      try {
+        DriveStatus status = CheckDriveInternal(path);
         promise->set_value(status);
+      } catch (const std::exception &e) {
+        DEBUG_LOG("[DriveStatusChecker] Exception in CheckDriveInternal: %s",
+                  e.what());
+        // Set exception instead of value so caller can handle it
+        try {
+          promise->set_exception(std::current_exception());
+        } catch (...) {
+          // Promise may have been abandoned if caller timed out
+        }
+      } catch (...) {
+        DEBUG_LOG(
+            "[DriveStatusChecker] Unknown exception in CheckDriveInternal");
+        try {
+          promise->set_exception(std::current_exception());
+        } catch (...) {
+          // Promise may have been abandoned if caller timed out
+        }
       }
     });
 
-    // Handle timeout in the caller
-    if (timeoutMs != INFINITE) {
-      std::thread([promise, state, timeoutMs]() {
-        std::this_thread::sleep_for(std::chrono::milliseconds(timeoutMs));
-        if (!state->exchange(true)) {
-          try {
-            promise->set_value(DriveStatus::Timeout);
-          } catch (...) {
-            // Promise already satisfied
-          }
-        }
-      }).detach();
-    }
-
     return future;
   }
 
+  // Overload that accepts timeoutMs for API compatibility (timeout is enforced
+  // in CheckDrive, not here)
+  static std::future<DriveStatus> CheckDriveAsync(const std::string &path,
+                                                  DWORD /*timeoutMs*/) {
+    return CheckDriveAsync(path);
+  }
+
   static DriveStatus CheckDrive(const std::string &path,
                                 DWORD timeoutMs = 5000) {
     try {
-      auto future = CheckDriveAsync(path, timeoutMs);
+      auto future = CheckDriveAsync(path);
+
+      // Use wait_for to enforce timeout - no detached threads needed!
+      // The worker thread continues running but we return Timeout to caller.
+      // The promise will eventually be satisfied (or abandoned).
+      auto waitResult = future.wait_for(std::chrono::milliseconds(timeoutMs));
 
-      if (future.wait_for(std::chrono::milliseconds(timeoutMs)) ==
-          std::future_status::timeout) {
+      if (waitResult == std::future_status::timeout) {
+        DEBUG_LOG("[DriveStatusChecker] Timeout waiting for drive %s",
+                  path.c_str());
         return DriveStatus::Timeout;
       }
 
+      // Future is ready - get the result (may throw if worker set exception)
       return future.get();
+    } catch (const std::exception &e) {
+      DEBUG_LOG("[DriveStatusChecker] Exception checking drive %s: %s",
+                path.c_str(), e.what());
+      return DriveStatus::Unknown;
     } catch (...) {
-      DEBUG_LOG("[DriveStatusChecker] Exception checking drive %s",
+      DEBUG_LOG("[DriveStatusChecker] Unknown exception checking drive %s",
                 path.c_str());
       return DriveStatus::Unknown;
     }
@@ -172,24 +179,42 @@ public:
     futures.reserve(paths.size());
 
     // Launch all checks concurrently
+    auto startTime = std::chrono::steady_clock::now();
     for (const auto &path : paths) {
-      futures.push_back(CheckDriveAsync(path, timeoutMs));
+      futures.push_back(CheckDriveAsync(path));
     }
 
-    // Collect results
+    // Collect results with timeout
     std::vector<DriveStatus> results;
     results.reserve(paths.size());
 
     for (size_t i = 0; i < futures.size(); ++i) {
       try {
-        if (futures[i].wait_for(std::chrono::milliseconds(timeoutMs)) ==
-            std::future_status::timeout) {
+        // Calculate remaining time for this future
+        auto elapsed = std::chrono::steady_clock::now() - startTime;
+        auto elapsedMs =
+            std::chrono::duration_cast<std::chrono::milliseconds>(elapsed)
+                .count();
+        auto remainingMs = (elapsedMs < static_cast<long long>(timeoutMs))
+                               ? static_cast<DWORD>(timeoutMs - elapsedMs)
+                               : 0;
+
+        if (remainingMs == 0 ||
+            futures[i].wait_for(std::chrono::milliseconds(remainingMs)) ==
+                std::future_status::timeout) {
+          DEBUG_LOG("[DriveStatusChecker] Timeout waiting for drive %s",
+                    paths[i].c_str());
           results.push_back(DriveStatus::Timeout);
         } else {
           results.push_back(futures[i].get());
         }
+      } catch (const std::exception &e) {
+        DEBUG_LOG(
+            "[DriveStatusChecker] Exception getting result for drive %s: %s",
+            paths[i].c_str(), e.what());
+        results.push_back(DriveStatus::Unknown);
       } catch (...) {
-        DEBUG_LOG("[DriveStatusChecker] Exception getting result for drive %s",
+        DEBUG_LOG("[DriveStatusChecker] Unknown exception for drive %s",
                   paths[i].c_str());
         results.push_back(DriveStatus::Unknown);
       }

package/src/windows/error_utils.h

@@ -62,8 +62,8 @@ private:
     size_t size = FormatMessageA(
         FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
             FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-        (LPSTR)&messageBuffer, 0, NULL);
+        nullptr, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        (LPSTR)&messageBuffer, 0, nullptr);
 
     // RAII guard ensures LocalFree is called even if exception thrown
     LocalFreeGuard guard(messageBuffer);

package/src/windows/security_utils.h

@@ -124,7 +124,7 @@ public:
 
   // Check if process has required privileges
   static bool HasRequiredPrivileges() {
-    HANDLE token;
+    HANDLE token = nullptr;
     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) {
       return false;
     }
@@ -169,7 +169,8 @@ public:
   }
 };
 
-// RAII wrapper for HANDLE resources
+// RAII wrapper for HANDLE resources (uses CloseHandle)
+// For search handles from FindFirstFile*, use FindHandleGuard instead
 class HandleGuard {
   HANDLE handle;
 
@@ -213,6 +214,48 @@ public:
   }
 };
 
+// RAII wrapper for search handles from FindFirstFile/FindFirstFileEx
+// These handles MUST be closed with FindClose, not CloseHandle.
+// See:
+// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-findclose
+class FindHandleGuard {
+  HANDLE handle;
+
+public:
+  explicit FindHandleGuard(HANDLE h) : handle(h) {}
+
+  ~FindHandleGuard() {
+    if (handle != INVALID_HANDLE_VALUE) {
+      FindClose(handle);
+    }
+  }
+
+  FindHandleGuard(FindHandleGuard &&other) noexcept : handle(other.handle) {
+    other.handle = INVALID_HANDLE_VALUE;
+  }
+
+  FindHandleGuard &operator=(FindHandleGuard &&other) noexcept {
+    if (this != &other) {
+      if (handle != INVALID_HANDLE_VALUE) {
+        FindClose(handle);
+      }
+      handle = other.handle;
+      other.handle = INVALID_HANDLE_VALUE;
+    }
+    return *this;
+  }
+
+  // Delete copy operations
+  FindHandleGuard(const FindHandleGuard &) = delete;
+  FindHandleGuard &operator=(const FindHandleGuard &) = delete;
+
+  HANDLE get() const { return handle; }
+
+  // Check if handle is valid (FindFirstFile returns INVALID_HANDLE_VALUE on
+  // failure, not NULL)
+  explicit operator bool() const { return handle != INVALID_HANDLE_VALUE; }
+};
+
 // RAII wrapper for critical sections
 class CriticalSectionGuard {
   CRITICAL_SECTION cs;
@@ -244,6 +287,8 @@ public:
     // Delete copy/move
     Lock(const Lock &) = delete;
     Lock &operator=(const Lock &) = delete;
+    Lock(Lock &&) = delete;
+    Lock &operator=(Lock &&) = delete;
   };
 };
 

package/src/windows/thread_pool.h

@@ -6,6 +6,8 @@
 #include <functional>
 #include <memory>
 #include <queue>
+#include <stdexcept>
+#include <string>
 #include <thread>
 #include <vector>
 
@@ -16,22 +18,45 @@ class WorkQueue {
 private:
   std::queue<std::function<void()>> tasks;
   CRITICAL_SECTION cs;
-  HANDLE workAvailable;
+  HANDLE workAvailable = nullptr;
   std::atomic<bool> shutdown{false};
+  bool initialized = false;
 
 public:
   WorkQueue() {
     InitializeCriticalSection(&cs);
+    // CreateEvent returns NULL on failure, not INVALID_HANDLE_VALUE.
+    // See:
+    // https://learn.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-createeventa
     workAvailable = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+    if (workAvailable == nullptr) {
+      DWORD error = GetLastError();
+      DeleteCriticalSection(&cs);
+      DEBUG_LOG("[WorkQueue] CreateEvent failed with error: %lu", error);
+      throw std::runtime_error("WorkQueue: CreateEvent failed with error " +
+                               std::to_string(error));
+    }
+    initialized = true;
   }
 
   ~WorkQueue() {
     shutdown = true;
-    SetEvent(workAvailable);
-    CloseHandle(workAvailable);
-    DeleteCriticalSection(&cs);
+    if (workAvailable != nullptr) {
+      SetEvent(workAvailable);
+      CloseHandle(workAvailable);
+      workAvailable = nullptr;
+    }
+    if (initialized) {
+      DeleteCriticalSection(&cs);
+    }
   }
 
+  // Delete copy/move operations - WorkQueue manages non-copyable resources
+  WorkQueue(const WorkQueue &) = delete;
+  WorkQueue &operator=(const WorkQueue &) = delete;
+  WorkQueue(WorkQueue &&) = delete;
+  WorkQueue &operator=(WorkQueue &&) = delete;
+
   void Push(std::function<void()> task) {
     EnterCriticalSection(&cs);
     tasks.push(std::move(task));

package/src/windows/volume_metadata.cpp

@@ -19,12 +19,12 @@ namespace {
 class WNetConnection {
   std::string drivePath;
   std::unique_ptr<char[]> buffer;
-  DWORD bufferSize;
+  DWORD bufferSize = MAX_PATH;
   bool isValid = false;
 
 public:
   explicit WNetConnection(const std::string &path)
-      : drivePath(path.substr(0, 2)), bufferSize(MAX_PATH) {
+      : drivePath(path.substr(0, 2)) {
 
     // Allocate initial buffer
     buffer = std::make_unique<char[]>(bufferSize);
@@ -41,6 +41,7 @@ public:
     isValid = (result == NO_ERROR);
   }
 
+  ~WNetConnection() = default;
   WNetConnection(WNetConnection &&) noexcept = default;
   WNetConnection &operator=(WNetConnection &&) noexcept = default;
 
@@ -85,12 +86,14 @@ inline std::string GetVolumeGUID(const std::string &mountPoint) {
 // RAII wrapper for volume information
 class VolumeInfo {
   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;
-  bool valid;
+  // Initialize all members to prevent reading uninitialized memory
+  // if GetVolumeInformationA fails with ERROR_NOT_READY
+  char volumeName[VOLUME_NAME_SIZE] = {0};
+  char fstype[VOLUME_NAME_SIZE] = {0};
+  DWORD serialNumber = 0;
+  DWORD maxComponentLen = 0;
+  DWORD fsFlags = 0;
+  bool valid = false;
 
 public:
   explicit VolumeInfo(const std::string &mountPoint) {
@@ -111,10 +114,12 @@ public:
 
 // RAII wrapper for disk space information
 class DiskSpaceInfo {
-  ULARGE_INTEGER totalBytes;
-  ULARGE_INTEGER freeBytes;
-  ULARGE_INTEGER totalFreeBytes;
-  bool valid;
+  // Initialize all members to prevent reading uninitialized memory
+  // if GetDiskFreeSpaceExA fails with ERROR_NOT_READY
+  ULARGE_INTEGER totalBytes = {0};
+  ULARGE_INTEGER freeBytes = {0};
+  ULARGE_INTEGER totalFreeBytes = {0};
+  bool valid = false;
 
 public:
   explicit DiskSpaceInfo(const std::string &mountPoint) {