X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwin32_replacements.c;h=527d4345264484123afde97f7b8e1bbc6fc06ef9;hp=36cc8a357e884a177c41b89eb9eee7c2493c7b02;hb=343b098498118f1554bd476d00d8233ec0cb9a6b;hpb=e8c3ca2d1d0cac3d64985b45a9f654d2029a7518 diff --git a/src/win32_replacements.c b/src/win32_replacements.c index 36cc8a35..527d4345 100644 --- a/src/win32_replacements.c +++ b/src/win32_replacements.c @@ -28,13 +28,16 @@ # include "config.h" #endif +#include #include #include /* for PathMatchSpecW() */ #include "wimlib/win32_common.h" #include "wimlib/assert.h" #include "wimlib/file_io.h" +#include "wimlib/glob.h" #include "wimlib/error.h" +#include "wimlib/wildcard.h" #include "wimlib/util.h" /* Replacement for POSIX fsync() */ @@ -55,7 +58,7 @@ err: return -1; } -/* Use the Win32 API to get the number of processors */ +/* Use the Win32 API to get the number of processors. */ unsigned win32_get_number_of_processors(void) { @@ -64,6 +67,17 @@ win32_get_number_of_processors(void) return sysinfo.dwNumberOfProcessors; } +/* Use the Win32 API to get the amount of available memory. */ +u64 +win32_get_avail_memory(void) +{ + MEMORYSTATUSEX status = { + .dwLength = sizeof(status), + }; + GlobalMemoryStatusEx(&status); + return status.ullTotalPhys; +} + /* Replacement for POSIX-2008 realpath(). Warning: partial functionality only * (resolved_path must be NULL). Also I highly doubt that GetFullPathName * really does the right thing under all circumstances. */ @@ -86,28 +100,93 @@ realpath(const wchar_t *path, wchar_t *resolved_path) ret = GetFullPathNameW(path, ret, resolved_path, NULL); if (!ret) { err = GetLastError(); - free(resolved_path); + FREE(resolved_path); resolved_path = NULL; goto fail_win32; } goto out; fail_win32: - errno = win32_error_to_errno(err); + set_errno_from_win32_error(err); out: return resolved_path; } -/* rename() on Windows fails if the destination file exists. And we need to - * make it work on wide characters. Fix it. */ +/* A quick hack to get reasonable rename() semantics on Windows, in particular + * deleting the destination file instead of failing with ERROR_FILE_EXISTS and + * working around any processes that may have the destination file open. + * + * Note: This is intended to be called when overwriting a regular file with an + * updated copy and is *not* a fully POSIX compliant rename(). For that you may + * wish to take a look at Cygwin's implementation, but be prepared... + * + * Return 0 on success, -1 on regular error, or 1 if the destination file was + * deleted but the source could not be renamed and therefore should not be + * deleted. + */ int -win32_rename_replacement(const wchar_t *oldpath, const wchar_t *newpath) +win32_rename_replacement(const wchar_t *srcpath, const wchar_t *dstpath) { - if (MoveFileExW(oldpath, newpath, MOVEFILE_REPLACE_EXISTING)) { + wchar_t *tmpname; + + /* Normally, MoveFileExW() with the MOVEFILE_REPLACE_EXISTING flag does + * what we want. */ + + if (MoveFileExW(srcpath, dstpath, MOVEFILE_REPLACE_EXISTING)) return 0; - } else { + + /* MoveFileExW() failed. One way this can happen is if any process has + * the destination file open, in which case ERROR_ACCESS_DENIED is + * produced. This can commonly happen if there is a backup or antivirus + * program monitoring or scanning the files. This behavior is very + * different from the behavior of POSIX rename(), which simply unlinks + * the destination file and allows other processes to keep it open! */ + + if (GetLastError() != ERROR_ACCESS_DENIED) + goto err_set_errno; + + /* We can work around the above-mentioned problem by renaming the + * destination file to yet another temporary file, then "deleting" it, + * which on Windows will in fact not actually delete it immediately but + * rather mark it for deletion when the last handle to it is closed. */ + { + static const wchar_t orig_suffix[5] = L".orig"; + const size_t num_rand_chars = 9; + wchar_t *p; + + size_t dstlen = wcslen(dstpath); + + tmpname = alloca(sizeof(wchar_t) * + (dstlen + ARRAY_LEN(orig_suffix) + num_rand_chars + 1)); + p = tmpname; + p = wmempcpy(p, dstpath, dstlen); + p = wmempcpy(p, orig_suffix, ARRAY_LEN(orig_suffix)); + randomize_char_array_with_alnum(p, num_rand_chars); + p += num_rand_chars; + *p = L'\0'; + } + + if (!MoveFile(dstpath, tmpname)) + goto err_set_errno; + + if (!DeleteFile(tmpname)) { set_errno_from_GetLastError(); - return -1; + WARNING_WITH_ERRNO("Failed to delete original file " + "(moved to \"%ls\")", tmpname); } + + if (!MoveFile(srcpath, dstpath)) { + set_errno_from_GetLastError(); + WARNING_WITH_ERRNO("Atomic semantics not respected in " + "failed rename() (new file is at \"%ls\")", + srcpath); + return 1; + } + + return 0; + +err_set_errno: + set_errno_from_GetLastError(); + return -1; } /* Replacement for POSIX fnmatch() (partial functionality only) */ @@ -146,7 +225,7 @@ fail_close_handle: fail: if (err == NO_ERROR) err = GetLastError(); - errno = win32_error_to_errno(err); + set_errno_from_win32_error(err); return -1; } @@ -177,12 +256,15 @@ do_pread_or_pwrite(int fd, void *buf, size_t count, off_t offset, OVERLAPPED overlapped; BOOL bret; - wimlib_assert(count <= 0xffffffff); - h = (HANDLE)_get_osfhandle(fd); if (h == INVALID_HANDLE_VALUE) goto err; + if (GetFileType(h) == FILE_TYPE_PIPE) { + errno = ESPIPE; + goto err; + } + /* Get original position */ relative_offset.QuadPart = 0; if (!SetFilePointerEx(h, relative_offset, &orig_offset, FILE_CURRENT)) @@ -229,6 +311,7 @@ pwrite(int fd, const void *buf, size_t count, off_t offset) return do_pread_or_pwrite(fd, (void*)buf, count, offset, true); } +#if 0 /* Dumb Windows implementation of writev(). It writes the vectors one at a * time. */ ssize_t writev(int fd, const struct iovec *iov, int iovcnt) @@ -253,30 +336,23 @@ ssize_t writev(int fd, const struct iovec *iov, int iovcnt) } return total_bytes_written; } +#endif int win32_get_file_and_vol_ids(const wchar_t *path, u64 *ino_ret, u64 *dev_ret) { - HANDLE hFile; - DWORD err; + HANDLE h; BY_HANDLE_FILE_INFORMATION file_info; int ret; + DWORD err; - hFile = win32_open_existing_file(path, FILE_READ_ATTRIBUTES); - if (hFile == INVALID_HANDLE_VALUE) { - err = GetLastError(); - if (err != ERROR_FILE_NOT_FOUND) { - WARNING("Failed to open \"%ls\" to get file " - "and volume IDs", path); - win32_error(err); - } - return WIMLIB_ERR_OPEN; + h = win32_open_existing_file(path, FILE_READ_ATTRIBUTES); + if (h == INVALID_HANDLE_VALUE) { + ret = WIMLIB_ERR_OPEN; + goto out; } - if (!GetFileInformationByHandle(hFile, &file_info)) { - err = GetLastError(); - ERROR("Failed to get file information for \"%ls\"", path); - win32_error(err); + if (!GetFileInformationByHandle(h, &file_info)) { ret = WIMLIB_ERR_STAT; } else { *ino_ret = ((u64)file_info.nFileIndexHigh << 32) | @@ -284,9 +360,115 @@ win32_get_file_and_vol_ids(const wchar_t *path, u64 *ino_ret, u64 *dev_ret) *dev_ret = file_info.dwVolumeSerialNumber; ret = 0; } - CloseHandle(hFile); + err = GetLastError(); + CloseHandle(h); + SetLastError(err); +out: + set_errno_from_GetLastError(); + return ret; +} + +/* Replacement for glob() in Windows native builds that operates on wide + * characters. */ +int +win32_wglob(const wchar_t *pattern, int flags, + int (*errfunc)(const wchar_t *epath, int eerrno), + glob_t *pglob) +{ + WIN32_FIND_DATAW dat; + DWORD err; + HANDLE hFind; + int ret; + size_t nspaces; + int errno_save; + + const wchar_t *backslash, *end_slash; + size_t prefix_len; + + backslash = wcsrchr(pattern, L'\\'); + end_slash = wcsrchr(pattern, L'/'); + + if (backslash > end_slash) + end_slash = backslash; + + if (end_slash) + prefix_len = end_slash - pattern + 1; + else + prefix_len = 0; + + /* This function does not support all functionality of the POSIX glob(), + * so make sure the parameters are consistent with supported + * functionality. */ + wimlib_assert(errfunc == NULL); + wimlib_assert((flags & GLOB_ERR) == GLOB_ERR); + wimlib_assert((flags & ~(GLOB_NOSORT | GLOB_ERR)) == 0); + + hFind = FindFirstFileW(pattern, &dat); + if (hFind == INVALID_HANDLE_VALUE) { + err = GetLastError(); + if (err == ERROR_FILE_NOT_FOUND) { + errno = 0; + return GLOB_NOMATCH; + } else { + set_errno_from_win32_error(err); + return GLOB_ABORTED; + } + } + pglob->gl_pathc = 0; + pglob->gl_pathv = NULL; + nspaces = 0; + do { + wchar_t *path; + if (pglob->gl_pathc == nspaces) { + size_t new_nspaces; + wchar_t **pathv; + + new_nspaces = nspaces * 2 + 1; + pathv = REALLOC(pglob->gl_pathv, + new_nspaces * sizeof(pglob->gl_pathv[0])); + if (!pathv) + goto oom; + pglob->gl_pathv = pathv; + nspaces = new_nspaces; + } + size_t filename_len = wcslen(dat.cFileName); + size_t len_needed = prefix_len + filename_len; + + path = MALLOC((len_needed + 1) * sizeof(wchar_t)); + if (!path) + goto oom; + + wmemcpy(path, pattern, prefix_len); + wmemcpy(path + prefix_len, dat.cFileName, filename_len + 1); + pglob->gl_pathv[pglob->gl_pathc++] = path; + } while (FindNextFileW(hFind, &dat)); + err = GetLastError(); + CloseHandle(hFind); + if (err != ERROR_NO_MORE_FILES) { + set_errno_from_win32_error(err); + ret = GLOB_ABORTED; + goto fail_globfree; + } + return 0; + +oom: + CloseHandle(hFind); + errno = ENOMEM; + ret = GLOB_NOSPACE; +fail_globfree: + errno_save = errno; + globfree(pglob); + errno = errno_save; return ret; } +void +globfree(glob_t *pglob) +{ + size_t i; + for (i = 0; i < pglob->gl_pathc; i++) + FREE(pglob->gl_pathv[i]); + FREE(pglob->gl_pathv); +} #endif /* __WIN32__ */