zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/utils/win/foreach_dirent_longpath.c

@@ -0,0 +1,292 @@
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h> // For struct stat definition (might need MinGW or similar)
+#include <time.h>     // For time_t
+#include "io.h"
+
+char *zsv_ensureLongPathPrefix(const char *original_path, unsigned char always_prefix);
+
+// Helpers
+static WCHAR *utf8_to_wide(const char *utf8_str);
+static char *wide_to_utf8(const WCHAR *wide_str);
+static void filetime_to_time_t(const FILETIME *ft, time_t *t);
+static void populate_stat_from_find_data(struct stat *s, const WIN32_FIND_DATAW *findData);
+
+// Windows-specific implementation
+static int zsv_foreach_dirent_aux(const char *dir_path_utf8, size_t depth, size_t max_depth,
+                                  zsv_foreach_dirent_handler handler, void *ctx, char verbose) {
+  int err = 0;
+  HANDLE hFind = INVALID_HANDLE_VALUE;
+  WCHAR *search_path_wide = NULL;
+  WCHAR *dir_path_wide = NULL;
+  char *prefixed_dir_path_utf8 = NULL; // For potential long path
+
+  if (!dir_path_utf8)
+    return 1; // Invalid input path
+
+  if (max_depth > 0 && depth >= max_depth)
+    return 0; // Max depth reached
+
+  // 1. Handle potential long path prefix (result must be freed)
+  prefixed_dir_path_utf8 = zsv_ensureLongPathPrefix(dir_path_utf8, 1);
+  const char *prefixed_dir_to_use = prefixed_dir_path_utf8 ? prefixed_dir_path_utf8 : dir_path_utf8;
+
+  // 2. Convert the (potentially prefixed) UTF-8 path to WCHAR (UTF-16) for Windows API
+  dir_path_wide = utf8_to_wide(prefixed_dir_to_use);
+  if (!dir_path_wide) {
+    fprintf(stderr, "Failed to convert path to wide char: %s\n", prefixed_dir_to_use);
+    free(prefixed_dir_path_utf8);
+    return 1;
+  }
+
+  // 3. Create the search pattern (e.g., "C:\\path\\*")
+  size_t dir_len = wcslen(dir_path_wide);
+  // Need space for path, backslash (optional), wildcard, and null terminator
+  search_path_wide = (WCHAR *)malloc((dir_len + 3) * sizeof(WCHAR));
+  if (!search_path_wide) {
+    fprintf(stderr, "Out of memory allocating search path!\n");
+    err = 1;
+    goto cleanup;
+  }
+  wcscpy_s(search_path_wide, dir_len + 3, dir_path_wide);
+  // Add trailing backslash if needed (robust check)
+  if (dir_len > 0 && search_path_wide[dir_len - 1] != L'\\' && search_path_wide[dir_len - 1] != L'/') {
+    search_path_wide[dir_len] = L'\\';
+    search_path_wide[dir_len + 1] = L'\0'; // Ensure null termination before appending wildcard
+  }
+  wcscat_s(search_path_wide, dir_len + 3, L"*"); // Append wildcard
+
+  // 4. Start finding files
+  WIN32_FIND_DATAW findData;
+  hFind = FindFirstFileW(search_path_wide, &findData);
+
+  if (hFind == INVALID_HANDLE_VALUE) {
+    // Check if the error is simply "directory not found" or similar benign cases
+    DWORD dwError = GetLastError();
+    if (dwError != ERROR_FILE_NOT_FOUND && dwError != ERROR_PATH_NOT_FOUND && dwError != ERROR_NO_MORE_FILES) {
+      // Report more serious errors
+      fprintf(stderr, "FindFirstFileW failed for %ls (Error %lu)\n", search_path_wide, dwError);
+      err = 1;
+      // Maybe add more specific error handling here if needed
+    }
+    // Otherwise, it's okay (e.g., empty dir or dir doesn't exist), just return
+    goto cleanup;
+  }
+
+  // 5. Iterate through directory entries
+  do {
+    // Skip "." and ".." entries
+    if (wcscmp(findData.cFileName, L".") == 0 || wcscmp(findData.cFileName, L"..") == 0) {
+      continue;
+    }
+
+    char *entry_name_utf8 = NULL;
+    char *full_path_utf8 = NULL;
+
+    // 6. Convert the found entry name (WCHAR) back to UTF-8
+    entry_name_utf8 = wide_to_utf8(findData.cFileName);
+    if (!entry_name_utf8) {
+      fprintf(stderr, "Failed to convert entry name to UTF-8\n");
+      err = 1;
+      // Attempt to continue with the next file? Or break? Let's try continuing.
+      continue;
+    }
+
+    // 7. Construct the full path IN UTF-8 using the ORIGINAL dir_path_utf8
+    // Need space for original path, separator, entry name, null terminator
+    size_t original_path_len = strlen(dir_path_utf8);
+    size_t entry_name_len = strlen(entry_name_utf8);
+    size_t full_path_len_needed = original_path_len + 1 + entry_name_len + 1;
+    full_path_utf8 = (char *)malloc(full_path_len_needed);
+
+    if (!full_path_utf8) {
+      fprintf(stderr, "Out of memory allocating full path!\n");
+      free(entry_name_utf8);
+      err = 1;
+      // If we can't construct the path, we probably should stop.
+      break;
+    }
+
+    strcpy_s(full_path_utf8, full_path_len_needed, dir_path_utf8);
+    // Append backslash if needed
+    if (original_path_len > 0 && dir_path_utf8[original_path_len - 1] != '\\' &&
+        dir_path_utf8[original_path_len - 1] != '/') {
+      strcat_s(full_path_utf8, full_path_len_needed, "\\");
+    }
+    strcat_s(full_path_utf8, full_path_len_needed, entry_name_utf8);
+
+    // 8. Prepare the handler structure
+    struct zsv_foreach_dirent_handle h = {0};
+    h.verbose = verbose;
+    h.parent = dir_path_utf8; // Use original non-prefixed path for handler
+    h.entry = entry_name_utf8;
+    h.parent_and_entry = full_path_utf8;
+    h.ctx = ctx;
+    h.is_dir = (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
+
+    // Populate the stat structure (best effort)
+    populate_stat_from_find_data(&h.stat, &findData);
+
+    // 9. Call the handler
+    if (handler) {
+      // Handler might set h.no_recurse
+      handler(&h, depth + 1);
+    }
+
+    // 10. Recurse if it's a directory and recursion is not disabled
+    if (h.is_dir && !h.no_recurse) {
+      int recurse_err = zsv_foreach_dirent_aux(full_path_utf8, depth + 1, max_depth, handler, ctx, verbose);
+      if (recurse_err) {
+        err = recurse_err; // Propagate error
+                           // Potentially break here if recursive errors should stop processing
+      }
+    }
+
+    // 11. Cleanup per-entry allocations
+    free(entry_name_utf8);
+    free(full_path_utf8);
+
+    if (err && !h.is_dir) { // Option: break if a non-recursive error occurred
+                            // break;
+    }
+
+  } while (FindNextFileW(hFind, &findData) != 0);
+
+  // Check for errors after the loop (FindNextFileW returns 0 on end or error)
+  DWORD dwError = GetLastError();
+  if (dwError != ERROR_NO_MORE_FILES) {
+    fprintf(stderr, "FindNextFileW failed (Error %lu)\n", dwError);
+    err = 1;
+  }
+
+cleanup:
+  // 12. Final Cleanup
+  if (hFind != INVALID_HANDLE_VALUE) {
+    FindClose(hFind);
+  }
+  free(search_path_wide);
+  free(dir_path_wide);
+  free(prefixed_dir_path_utf8); // Free the path possibly returned by zsv_ensureLongPathPrefix
+
+  return err;
+}
+
+// --- Helper Function Implementations ---
+
+// Converts a UTF-8 string to a newly allocated WCHAR (UTF-16) string.
+// Returns NULL on failure. Caller must free the returned pointer.
+static WCHAR *utf8_to_wide(const char *utf8_str) {
+  if (!utf8_str)
+    return NULL;
+  int chars_needed = MultiByteToWideChar(CP_UTF8, 0, utf8_str, -1, NULL, 0);
+  if (chars_needed <= 0) {
+    // fprintf(stderr, "MultiByteToWideChar (pre-flight) failed with error %lu\n", GetLastError());
+    return NULL;
+  }
+  WCHAR *wide_str = (WCHAR *)malloc(chars_needed * sizeof(WCHAR));
+  if (!wide_str) {
+    // fprintf(stderr, "Failed to allocate memory for wide string\n");
+    return NULL;
+  }
+  int chars_converted = MultiByteToWideChar(CP_UTF8, 0, utf8_str, -1, wide_str, chars_needed);
+  if (chars_converted <= 0) {
+    // fprintf(stderr, "MultiByteToWideChar failed with error %lu\n", GetLastError());
+    free(wide_str);
+    return NULL;
+  }
+  return wide_str;
+}
+
+// Converts a WCHAR (UTF-16) string to a newly allocated UTF-8 string.
+// Returns NULL on failure. Caller must free the returned pointer.
+static char *wide_to_utf8(const WCHAR *wide_str) {
+  if (!wide_str)
+    return NULL;
+  int bytes_needed = WideCharToMultiByte(CP_UTF8, 0, wide_str, -1, NULL, 0, NULL, NULL);
+  if (bytes_needed <= 0) {
+    // fprintf(stderr, "WideCharToMultiByte (pre-flight) failed with error %lu\n", GetLastError());
+    return NULL;
+  }
+  char *utf8_str = (char *)malloc(bytes_needed); // Bytes includes null terminator
+  if (!utf8_str) {
+    // fprintf(stderr, "Failed to allocate memory for utf8 string\n");
+    return NULL;
+  }
+  int bytes_converted = WideCharToMultiByte(CP_UTF8, 0, wide_str, -1, utf8_str, bytes_needed, NULL, NULL);
+  if (bytes_converted <= 0) {
+    // fprintf(stderr, "WideCharToMultiByte failed with error %lu\n", GetLastError());
+    free(utf8_str);
+    return NULL;
+  }
+  return utf8_str;
+}
+
+// Converts Windows FILETIME to POSIX time_t.
+// See https://stackoverflow.com/questions/6161776/convert-windows-filetime-to-second-in-unix-linux
+static void filetime_to_time_t(const FILETIME *ft, time_t *t) {
+  ULARGE_INTEGER uli;
+  uli.LowPart = ft->dwLowDateTime;
+  uli.HighPart = ft->dwHighDateTime;
+  // Windows FILETIME is 100-nanosecond intervals since January 1, 1601.
+  // time_t is seconds since January 1, 1970.
+  // Difference is 11644473600 seconds.
+  const ULONGLONG epoch_diff = 116444736000000000ULL;
+  if (uli.QuadPart < epoch_diff) {
+    *t = 0; // Time is before the Unix epoch
+  } else {
+    *t = (time_t)((uli.QuadPart - epoch_diff) / 10000000ULL);
+  }
+}
+
+// Populates a struct stat (partially) from WIN32_FIND_DATAW.
+// This is a best-effort mapping as not all fields have direct equivalents.
+static void populate_stat_from_find_data(struct stat *s, const WIN32_FIND_DATAW *findData) {
+  memset(s, 0, sizeof(struct stat)); // Initialize all fields to 0
+
+  // File Type and Mode (Basic)
+  if (findData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+    s->st_mode |= S_IFDIR | 0755; // Directory with typical permissions
+  } else {
+    s->st_mode |= S_IFREG | 0644; // Regular file with typical permissions
+  }
+  if (findData->dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
+    s->st_mode &= ~0222; // Remove write permissions
+  }
+
+  // File Size
+  ULARGE_INTEGER fileSize;
+  fileSize.LowPart = findData->nFileSizeLow;
+  fileSize.HighPart = findData->nFileSizeHigh;
+// Be careful about potential truncation if using a 32-bit build and large files
+// Using LONGLONG cast for intermediate calculation might help, but st_size might still be 32-bit
+#ifdef _WIN64
+  s->st_size = fileSize.QuadPart;
+#else
+  // Potential truncation for files > 4GB on 32-bit builds where st_size is 32-bit
+  if (fileSize.QuadPart > 0xFFFFFFFF) {
+    s->st_size = 0xFFFFFFFF; // Max value for 32-bit unsigned? Or -1? Check definition.
+                             // Consider logging a warning here
+  } else {
+    s->st_size = fileSize.LowPart; // Assuming st_size is 32-bit here
+  }
+  // A better approach for 32-bit might involve using _stati64 and struct __stat64
+  // but that changes the struct zsv_foreach_dirent_handle definition slightly.
+  // Sticking to standard 'struct stat' as requested for now.
+#endif
+
+  // Timestamps
+  filetime_to_time_t(&findData->ftCreationTime, &s->st_ctime);
+  filetime_to_time_t(&findData->ftLastAccessTime, &s->st_atime);
+  filetime_to_time_t(&findData->ftLastWriteTime, &s->st_mtime);
+
+  // Other fields (st_dev, st_ino, st_nlink, st_uid, st_gid)
+  // These don't have direct, easily accessible equivalents in WIN32_FIND_DATAW.
+  // Setting them to 0 or default values.
+  s->st_nlink = 1; // Typically 1 for files on Windows, can be >1 for dirs but hard to get
+                   // s->st_dev = 0; // No easy equivalent
+                   // s->st_ino = 0; // No easy equivalent (File ID requires GetFileInformationByHandle)
+                   // s->st_uid = 0; // No concept of Unix UID/GID
+                   // s->st_gid = 0;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/win/io.c

@@ -0,0 +1,259 @@
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include <windows.h>        // For CreateDirectoryW, MultiByteToWideChar, GetLastError etc.
+#include <stdio.h>          // For printf, perror
+#include <stdlib.h>         // For malloc, free, exit
+#include <string.h>         // For strlen, strcpy, strncpy
+#include <wchar.h>          // For wide character types and functions like wcslen, wcscpy
+
+static char *slashes_to_backslashes_if_needed(const char *path, DWORD *rc) {
+  char *tmp = NULL;
+  if (strchr(path, '/')) {
+    tmp = strdup(path);
+    if (!tmp) {
+      perror(path);
+      *rc = ERROR_OUTOFMEMORY;
+      return NULL;
+    }
+    for (size_t i = 0, j = strlen(path); i < j; i++)
+      if (tmp[i] == '/')
+        tmp[i] = '\\';
+  }
+  *rc = 0;
+  return tmp;
+}
+
+// Convert slashes to backslashes and then
+// make sure we have "\\\\?\\" or "\\\\?\\UNC\\" prefix if/as necessary or requested
+// Note: We assume the input 'original_path' is UTF-8 encoded.
+// The returned path, if not NULL, will also be UTF-8 encoded.
+char *zsv_ensureLongPathPrefix(const char *original_path, unsigned char always_prefix) {
+  if (original_path == NULL || original_path[0] == '\0') {
+    return NULL; // Handle NULL or empty input
+  }
+
+  wchar_t *wide_original_path = NULL;
+  wchar_t *wide_full_path = NULL;
+  wchar_t *prefixed_wide_path = NULL;
+  char *result_path_utf8 = NULL;
+  DWORD last_error = 0;
+
+  // --- 1. Convert input UTF-8 path to wide char (UTF-16) ---
+  int original_len_bytes = strlen(original_path);
+  int wide_len_needed = MultiByteToWideChar(CP_UTF8, 0, original_path, original_len_bytes, NULL, 0);
+  if (wide_len_needed == 0) {
+    last_error = GetLastError();
+    fprintf(stderr, "zsv_ensureLongPathPrefix: MultiByteToWideChar (size check) failed: %lu\n", last_error);
+    goto cleanup;
+  }
+
+  wide_original_path = (wchar_t *)malloc((wide_len_needed + 1) * sizeof(wchar_t));
+  if (!wide_original_path) {
+    perror("zsv_ensureLongPathPrefix: malloc for wide_original_path failed");
+    goto cleanup;
+  }
+  int converted_chars =
+    MultiByteToWideChar(CP_UTF8, 0, original_path, original_len_bytes, wide_original_path, wide_len_needed);
+  if (converted_chars == 0) {
+    last_error = GetLastError();
+    fprintf(stderr, "zsv_ensureLongPathPrefix: MultiByteToWideChar failed: %lu\n", last_error);
+    goto cleanup;
+  }
+  wide_original_path[wide_len_needed] = L'\0'; // Null-terminate
+
+  // --- 2. Get the full absolute path using GetFullPathNameW ---
+  DWORD full_path_len_needed_wchars = GetFullPathNameW(wide_original_path, 0, NULL, NULL);
+  if (full_path_len_needed_wchars == 0) {
+    last_error = GetLastError();
+    fprintf(stderr, "zsv_ensureLongPathPrefix: GetFullPathNameW (size check) failed for '%ls': %lu\n",
+            wide_original_path, last_error);
+    goto cleanup;
+  }
+
+  wide_full_path = (wchar_t *)malloc(full_path_len_needed_wchars * sizeof(wchar_t));
+  if (!wide_full_path) {
+    perror("zsv_ensureLongPathPrefix: malloc for wide_full_path failed");
+    goto cleanup;
+  }
+
+  DWORD full_path_len_copied_wchars =
+    GetFullPathNameW(wide_original_path, full_path_len_needed_wchars, wide_full_path, NULL);
+  if (full_path_len_copied_wchars == 0 || full_path_len_copied_wchars >= full_path_len_needed_wchars) {
+    last_error = GetLastError();
+    // Error or buffer too small (shouldn't happen with correct size check)
+    fprintf(stderr, "zsv_ensureLongPathPrefix: GetFullPathNameW failed or buffer issue for '%ls': %lu\n",
+            wide_original_path, last_error);
+    goto cleanup;
+  }
+  // wide_full_path now contains the absolute path, null-terminated, with backslashes.
+
+  // Original wide path no longer needed
+  free(wide_original_path);
+  wide_original_path = NULL;
+
+  // --- 3. Check length of the ABSOLUTE path and always_prefix flag ---
+  size_t absolute_path_wlen = wcslen(wide_full_path); // Use wcslen for clarity
+
+  if (absolute_path_wlen < MAX_PATH && !always_prefix) {
+    // Path is short, and we don't always prefix.
+    // Return NULL as per the original function's contract for non-prefixing cases.
+    goto cleanup; // result_path_utf8 is already NULL
+  }
+
+  // --- Path is long (>= MAX_PATH) or always_prefix is set ---
+
+  // --- Define prefixes (wide char) ---
+  const wchar_t *prefix_std = L"\\\\?\\";
+  const wchar_t *prefix_unc = L"\\\\?\\UNC\\";
+  const size_t prefix_std_len = 4; // wcslen(prefix_std)
+  const size_t prefix_unc_len = 8; // wcslen(prefix_unc)
+
+  // --- 4. Check if the absolute path is already correctly prefixed ---
+  if (wcsncmp(wide_full_path, prefix_std, prefix_std_len) == 0 ||
+      wcsncmp(wide_full_path, prefix_unc, prefix_unc_len) == 0) {
+    // Already has a standard or UNC prefix.
+    // We still need to return it (converted back to UTF-8) because
+    // prefixing *was* deemed necessary (long path or always_prefix=true).
+    prefixed_wide_path = wide_full_path; // Use the existing full path
+    wide_full_path = NULL;               // Prevent double free
+  } else {
+    // --- Needs prefixing ---
+
+    // Determine if it's a UNC path (starts with \\ but not \\?)
+    // GetFullPathNameW should return paths like \\server\share...
+    BOOL is_unc = (absolute_path_wlen >= 2 && wide_full_path[0] == L'\\' && wide_full_path[1] == L'\\');
+
+    size_t new_wide_size_wchars = 0;
+
+    if (is_unc) {
+      // UNC Path: Needs \\?\UNC\ prefix
+      // Path part starts after the leading '\\'
+      const wchar_t *path_part = wide_full_path + 2;
+      size_t path_part_len = wcslen(path_part);
+      // New size = prefix len + path part len + 1 (null)
+      new_wide_size_wchars = prefix_unc_len + path_part_len + 1;
+      prefixed_wide_path = (wchar_t *)malloc(new_wide_size_wchars * sizeof(wchar_t));
+      if (!prefixed_wide_path) {
+        perror("zsv_ensureLongPathPrefix (UNC): malloc failed");
+        goto cleanup;
+      }
+      // Construct: wcscpy + wcscat is safe here due to exact size calculation
+      wcscpy(prefixed_wide_path, prefix_unc);
+      wcscat(prefixed_wide_path, path_part); // Append server\share...
+    } else {
+      // Standard Path: Needs \\?\ prefix
+      // New size = prefix len + original absolute path len + 1 (null)
+      new_wide_size_wchars = prefix_std_len + absolute_path_wlen + 1;
+      prefixed_wide_path = (wchar_t *)malloc(new_wide_size_wchars * sizeof(wchar_t));
+      if (!prefixed_wide_path) {
+        perror("zsv_ensureLongPathPrefix (STD): malloc failed");
+        goto cleanup;
+      }
+      // Construct: wcscpy + wcscat is safe here
+      wcscpy(prefixed_wide_path, prefix_std);
+      wcscat(prefixed_wide_path, wide_full_path);
+    }
+  }
+
+  // --- 5. Convert the (potentially) prefixed wide path back to UTF-8 ---
+  if (prefixed_wide_path) { // Should always be true if we reach here
+                            // Pass -1 for null termination handling
+    int utf8_len_needed = WideCharToMultiByte(CP_UTF8, 0, prefixed_wide_path, -1, NULL, 0, NULL, NULL);
+    if (utf8_len_needed == 0) {
+      last_error = GetLastError();
+      fprintf(stderr, "zsv_ensureLongPathPrefix: WideCharToMultiByte (size check) failed: %lu\n", last_error);
+      goto cleanup;
+    }
+
+    result_path_utf8 = (char *)malloc(utf8_len_needed); // Includes null terminator space
+    if (!result_path_utf8) {
+      perror("zsv_ensureLongPathPrefix: malloc for final result_path_utf8 failed");
+      goto cleanup;
+    }
+
+    int bytes_written =
+      WideCharToMultiByte(CP_UTF8, 0, prefixed_wide_path, -1, result_path_utf8, utf8_len_needed, NULL, NULL);
+    if (bytes_written == 0) {
+      last_error = GetLastError();
+      fprintf(stderr, "zsv_ensureLongPathPrefix: WideCharToMultiByte failed: %lu\n", last_error);
+      // Free the allocated result buffer before cleaning up others
+      free(result_path_utf8);
+      result_path_utf8 = NULL;
+      goto cleanup;
+    }
+  }
+
+cleanup:
+  // Free intermediate allocations
+  free(wide_original_path); // Safe to free NULL
+  free(wide_full_path);     // Safe to free NULL (will be NULL if assigned to prefixed_wide_path or on early exit)
+  free(prefixed_wide_path); // Safe to free NULL (will be NULL if no prefixing happened or on early exit)
+
+  // Return the final UTF-8 path (which is NULL if no prefixing was needed or if an error occurred)
+  return result_path_utf8;
+}
+
+DWORD zsv_pathToPrefixedWidePath(const char *path_utf8, wchar_t **result) {
+  // --- Input Validation ---
+  if (!path_utf8 || !result) {
+    return ERROR_INVALID_PARAMETER;
+  }
+  *result = NULL; // Initialize result pointer
+
+  // --- Intermediate Variables ---
+  char *prefixed_utf8 = NULL;         // Result from zsv_ensureLongPathPrefix
+  const char *utf8_to_convert = NULL; // Points to the UTF-8 string to be converted
+  wchar_t *final_wide_path = NULL;    // Final result path pointer (was intermediate)
+  DWORD error_code = 0;               // Holds error codes
+
+  // --- 2. Add prefix
+  prefixed_utf8 = zsv_ensureLongPathPrefix(path_utf8, 1);
+  // If prefixed_utf8 is not NULL, it's newly allocated (with correct prefix).
+  // If NULL, the path was short or already correctly prefixed.
+
+  // Determine the final UTF-8 string to convert to wide char
+  utf8_to_convert = prefixed_utf8 ? prefixed_utf8 : path_utf8;
+
+  // --- 3. Convert Selected UTF-8 Path to Wide Char (UTF-16) ---
+  // Calculate required buffer size (including null terminator)
+  int wideCharLen = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8_to_convert, -1, NULL, 0);
+  if (wideCharLen == 0) {
+    error_code = GetLastError();
+    fprintf(stderr, "Error calculating wide char length for '%s': %lu\n", utf8_to_convert, error_code);
+    goto cleanup;
+  }
+
+  // Allocate buffer
+  final_wide_path = (wchar_t *)calloc(wideCharLen + 1, sizeof(wchar_t));
+  if (!final_wide_path) {
+    perror("Error allocating memory for final wide path");
+    error_code = ERROR_OUTOFMEMORY;
+    goto cleanup;
+  }
+
+  // Perform conversion
+  if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8_to_convert, -1, final_wide_path, wideCharLen) == 0) {
+    error_code = GetLastError();
+    fprintf(stderr, "Error converting path '%s' to wide char: %lu\n", utf8_to_convert, error_code);
+    // final_wide_path will be freed in cleanup
+    goto cleanup;
+  }
+  // final_wide_path now holds the result, correctly prefixed if needed.
+
+  // --- 4. Set Result and Return Success ---
+  // The intermediate wide path is now the final path.
+  *result = final_wide_path;
+  final_wide_path = NULL; // Prevent freeing in cleanup as ownership is transferred
+  error_code = 0;         // Success
+
+cleanup:
+  // Free all intermediate allocations. free(NULL) is safe.
+  free(prefixed_utf8);
+  free(final_wide_path); // Free only if not transferred to *result
+
+  // If an error occurred before setting *result, ensure it's NULL
+  if (error_code != 0) {
+    *result = NULL;
+  }
+
+  return error_code;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/win/io.h

@@ -0,0 +1,13 @@
+#ifndef ZSV_WIN_UTILS_IO_H
+#define ZSV_WIN_UTILS_IO_H
+
+#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
+#include <windows.h>        // For CreateDirectoryW, MultiByteToWideChar, GetLastError etc.
+#include <stdio.h>          // For printf, perror
+#include <stdlib.h>         // For malloc, free, exit
+#include <string.h>         // For strlen, strcpy, strncpy
+#include <wchar.h>          // For wide character types and functions like wcslen, wcscpy
+
+DWORD zsv_pathToPrefixedWidePath(const char *path_utf8, wchar_t **result);
+
+#endif