X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fwin32_common.c;h=a1c3378e92ccb04e8384f83098f027c30315f545;hb=1bba32f7f1068eaa0e8de77b8afa99af68bcb44d;hp=26a4d75a93121ce03174a2a8cc314c46db5dc306;hpb=51f8edf82794f07055e3d9bcc8cd51bf0d86fae0;p=wimlib diff --git a/src/win32_common.c b/src/win32_common.c index 26a4d75a..a1c3378e 100644 --- a/src/win32_common.c +++ b/src/win32_common.c @@ -3,22 +3,20 @@ */ /* - * Copyright (C) 2013 Eric Biggers + * Copyright (C) 2013, 2014 Eric Biggers * - * This file is part of wimlib, a library for working with WIM files. + * This file is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the Free + * Software Foundation; either version 3 of the License, or (at your option) any + * later version. * - * wimlib is free software; you can redistribute it and/or modify it under the - * terms of the GNU General Public License as published by the Free - * Software Foundation; either version 3 of the License, or (at your option) - * any later version. - * - * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY - * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR - * A PARTICULAR PURPOSE. See the GNU General Public License for more + * This file is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * - * You should have received a copy of the GNU General Public License - * along with wimlib; if not, see http://www.gnu.org/licenses/. + * You should have received a copy of the GNU Lesser General Public License + * along with this file; if not, see http://www.gnu.org/licenses/. */ #ifdef __WIN32__ @@ -29,12 +27,7 @@ #include -#ifdef WITH_NTDLL -# include -#endif - #include "wimlib/win32_common.h" -#include "wimlib/assert.h" #include "wimlib/error.h" #include "wimlib/util.h" @@ -307,7 +300,6 @@ win32_error_to_errno(DWORD err_code) } } - void set_errno_from_win32_error(DWORD err) { @@ -320,133 +312,11 @@ set_errno_from_GetLastError(void) set_errno_from_win32_error(GetLastError()); } -#ifdef WITH_NTDLL void set_errno_from_nt_status(NTSTATUS status) { set_errno_from_win32_error((*func_RtlNtStatusToDosError)(status)); } -#endif - -/* Given a Windows-style path, return the number of characters of the prefix - * that specify the path to the root directory of a drive, or return 0 if the - * drive is relative (or at least on the current drive, in the case of - * absolute-but-not-really-absolute paths like \Windows\System32) */ -static size_t -win32_path_drive_spec_len(const wchar_t *path) -{ - size_t n = 0; - - if (!wcsncmp(path, L"\\\\?\\", 4)) { - /* \\?\-prefixed path. Check for following drive letter and - * path separator. */ - if (path[4] != L'\0' && path[5] == L':' && - is_any_path_separator(path[6])) - n = 7; - } else { - /* Not a \\?\-prefixed path. Check for an initial drive letter - * and path separator. */ - if (path[0] != L'\0' && path[1] == L':' && - is_any_path_separator(path[2])) - n = 3; - } - /* Include any additional path separators.*/ - if (n > 0) - while (is_any_path_separator(path[n])) - n++; - return n; -} - -bool -win32_path_is_root_of_drive(const wchar_t *path) -{ - size_t drive_spec_len; - wchar_t full_path[32768]; - DWORD ret; - - ret = GetFullPathName(path, ARRAY_LEN(full_path), full_path, NULL); - if (ret > 0 && ret < ARRAY_LEN(full_path)) - path = full_path; - - /* Explicit drive letter and path separator? */ - drive_spec_len = win32_path_drive_spec_len(path); - if (drive_spec_len > 0 && path[drive_spec_len] == L'\0') - return true; - - /* All path separators? */ - for (const wchar_t *p = path; *p != L'\0'; p++) - if (!is_any_path_separator(*p)) - return false; - return true; -} - - -/* Given a path, which may not yet exist, get a set of flags that describe the - * features of the volume the path is on. */ -int -win32_get_vol_flags(const wchar_t *path, unsigned *vol_flags_ret, - bool *supports_SetFileShortName_ret) -{ - wchar_t *volume; - BOOL bret; - DWORD vol_flags; - size_t drive_spec_len; - wchar_t filesystem_name[MAX_PATH + 1]; - - if (supports_SetFileShortName_ret) - *supports_SetFileShortName_ret = false; - - drive_spec_len = win32_path_drive_spec_len(path); - - if (drive_spec_len == 0) - if (path[0] != L'\0' && path[1] == L':') /* Drive-relative path? */ - drive_spec_len = 2; - - if (drive_spec_len == 0) { - /* Path does not start with a drive letter; use the volume of - * the current working directory. */ - volume = NULL; - } else { - /* Path starts with a drive letter (or \\?\ followed by a drive - * letter); use it. */ - volume = alloca((drive_spec_len + 2) * sizeof(wchar_t)); - wmemcpy(volume, path, drive_spec_len); - /* Add trailing backslash in case this was a drive-relative - * path. */ - volume[drive_spec_len] = L'\\'; - volume[drive_spec_len + 1] = L'\0'; - } - bret = GetVolumeInformation( - volume, /* lpRootPathName */ - NULL, /* lpVolumeNameBuffer */ - 0, /* nVolumeNameSize */ - NULL, /* lpVolumeSerialNumber */ - NULL, /* lpMaximumComponentLength */ - &vol_flags, /* lpFileSystemFlags */ - filesystem_name, /* lpFileSystemNameBuffer */ - ARRAY_LEN(filesystem_name)); /* nFileSystemNameSize */ - if (!bret) { - set_errno_from_GetLastError(); - WARNING_WITH_ERRNO("Failed to get volume information for " - "path \"%ls\"", path); - vol_flags = 0xffffffff; - goto out; - } - - if (wcsstr(filesystem_name, L"NTFS")) { - /* FILE_SUPPORTS_HARD_LINKS is only supported on Windows 7 and later. - * Force it on anyway if filesystem is NTFS. */ - vol_flags |= FILE_SUPPORTS_HARD_LINKS; - - if (supports_SetFileShortName_ret) - *supports_SetFileShortName_ret = true; - } - -out: - DEBUG("using vol_flags = %x", vol_flags); - *vol_flags_ret = vol_flags; - return 0; -} static bool win32_modify_privilege(const wchar_t *privilege, bool enable) @@ -499,41 +369,48 @@ win32_release_capture_and_apply_privileges(void) win32_modify_apply_privileges(false); } -HANDLE -win32_open_existing_file(const wchar_t *path, DWORD dwDesiredAccess) -{ - return CreateFileW(path, - dwDesiredAccess, - FILE_SHARE_READ, - NULL, /* lpSecurityAttributes */ - OPEN_EXISTING, - FILE_FLAG_BACKUP_SEMANTICS | - FILE_FLAG_OPEN_REPARSE_POINT, - NULL /* hTemplateFile */); -} - -/* Pointers to functions that are not available on all targetted versions of - * Windows (XP and later). NOTE: The WINAPI annotations seem to be important; I - * assume it specifies a certain calling convention. */ - -/* Vista and later */ -HANDLE (WINAPI *win32func_FindFirstStreamW)(LPCWSTR lpFileName, - STREAM_INFO_LEVELS InfoLevel, - LPVOID lpFindStreamData, - DWORD dwFlags) = NULL; - -/* Vista and later */ -BOOL (WINAPI *win32func_FindNextStreamW)(HANDLE hFindStream, - LPVOID lpFindStreamData) = NULL; - -/* Vista and later */ -BOOL (WINAPI *win32func_CreateSymbolicLinkW)(const wchar_t *lpSymlinkFileName, - const wchar_t *lpTargetFileName, - DWORD dwFlags) = NULL; - -#ifdef WITH_NTDLL - -DWORD (WINAPI *func_RtlNtStatusToDosError)(NTSTATUS status); +/* Pointers to dynamically loaded functions */ + +/* ntdll.dll */ + +NTSTATUS (WINAPI *func_NtCreateFile)(PHANDLE FileHandle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, + PIO_STATUS_BLOCK IoStatusBlock, + PLARGE_INTEGER AllocationSize, + ULONG FileAttributes, + ULONG ShareAccess, + ULONG CreateDisposition, + ULONG CreateOptions, + PVOID EaBuffer, + ULONG EaLength); + +NTSTATUS (WINAPI *func_NtOpenFile) (PHANDLE FileHandle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, + PIO_STATUS_BLOCK IoStatusBlock, + ULONG ShareAccess, + ULONG OpenOptions); + +NTSTATUS (WINAPI *func_NtReadFile) (HANDLE FileHandle, + HANDLE Event, + PIO_APC_ROUTINE ApcRoutine, + PVOID ApcContext, + PIO_STATUS_BLOCK IoStatusBlock, + PVOID Buffer, + ULONG Length, + PLARGE_INTEGER ByteOffset, + PULONG Key); + +NTSTATUS (WINAPI *func_NtWriteFile) (HANDLE FileHandle, + HANDLE Event, + PIO_APC_ROUTINE ApcRoutine, + PVOID ApcContext, + PIO_STATUS_BLOCK IoStatusBlock, + PVOID Buffer, + ULONG Length, + PLARGE_INTEGER ByteOffset, + PULONG Key); NTSTATUS (WINAPI *func_NtQueryInformationFile)(HANDLE FileHandle, PIO_STATUS_BLOCK IoStatusBlock, @@ -559,122 +436,232 @@ NTSTATUS (WINAPI *func_NtQueryDirectoryFile) (HANDLE FileHandle, PUNICODE_STRING FileName, BOOLEAN RestartScan); +NTSTATUS (WINAPI *func_NtQueryVolumeInformationFile) (HANDLE FileHandle, + PIO_STATUS_BLOCK IoStatusBlock, + PVOID FsInformation, + ULONG Length, + FS_INFORMATION_CLASS FsInformationClass); + +NTSTATUS (WINAPI *func_NtSetInformationFile)(HANDLE FileHandle, + PIO_STATUS_BLOCK IoStatusBlock, + PVOID FileInformation, + ULONG Length, + FILE_INFORMATION_CLASS FileInformationClass); + NTSTATUS (WINAPI *func_NtSetSecurityObject)(HANDLE Handle, SECURITY_INFORMATION SecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptor); -#endif /* WITH_NTDLL */ +NTSTATUS (WINAPI *func_NtFsControlFile) (HANDLE FileHandle, + HANDLE Event, + PIO_APC_ROUTINE ApcRoutine, + PVOID ApcContext, + PIO_STATUS_BLOCK IoStatusBlock, + ULONG FsControlCode, + PVOID InputBuffer, + ULONG InputBufferLength, + PVOID OutputBuffer, + ULONG OutputBufferLength); -static OSVERSIONINFO windows_version_info = { - .dwOSVersionInfoSize = sizeof(OSVERSIONINFO), -}; +NTSTATUS (WINAPI *func_NtClose) (HANDLE Handle); -static HMODULE hKernel32 = NULL; +DWORD (WINAPI *func_RtlNtStatusToDosError)(NTSTATUS status); -#ifdef WITH_NTDLL -static HMODULE hNtdll = NULL; -#endif +BOOLEAN (WINAPI *func_RtlDosPathNameToNtPathName_U) + (IN PCWSTR DosName, + OUT PUNICODE_STRING NtName, + OUT PCWSTR *PartName, + OUT PRTL_RELATIVE_NAME_U RelativeName); + +NTSTATUS (WINAPI *func_RtlDosPathNameToNtPathName_U_WithStatus) + (IN PCWSTR DosName, + OUT PUNICODE_STRING NtName, + OUT PCWSTR *PartName, + OUT PRTL_RELATIVE_NAME_U RelativeName); + +NTSTATUS (WINAPI *func_RtlCreateSystemVolumeInformationFolder) + (PCUNICODE_STRING VolumeRootPath); static bool acquired_privileges = false; -bool -windows_version_is_at_least(unsigned major, unsigned minor) +struct dll_sym { + void **func_ptr; + const char *name; + bool required; +}; + +#define DLL_SYM(name, required) { (void **)&func_##name, #name, required } + +#define for_each_sym(sym, spec) \ + for ((sym) = (spec)->syms; (sym)->name; (sym)++) + +struct dll_spec { + const wchar_t *name; + HMODULE handle; + const struct dll_sym syms[]; +}; + +struct dll_spec ntdll_spec = { + .name = L"ntdll.dll", + .syms = { + DLL_SYM(NtCreateFile, true), + DLL_SYM(NtOpenFile, true), + DLL_SYM(NtReadFile, true), + DLL_SYM(NtWriteFile, true), + DLL_SYM(NtQueryInformationFile, true), + DLL_SYM(NtQuerySecurityObject, true), + DLL_SYM(NtQueryDirectoryFile, true), + DLL_SYM(NtQueryVolumeInformationFile, true), + DLL_SYM(NtSetInformationFile, true), + DLL_SYM(NtSetSecurityObject, true), + DLL_SYM(NtFsControlFile, true), + DLL_SYM(NtClose, true), + DLL_SYM(RtlNtStatusToDosError, true), + DLL_SYM(RtlCreateSystemVolumeInformationFolder, false), + DLL_SYM(RtlDosPathNameToNtPathName_U, true), + DLL_SYM(RtlDosPathNameToNtPathName_U_WithStatus, false), /* Not present on XP */ + {NULL, NULL}, + }, +}; + +static int +init_dll(struct dll_spec *spec) +{ + const struct dll_sym *sym; + void *addr; + + if (!spec->handle) + spec->handle = LoadLibrary(spec->name); + if (!spec->handle) { + for_each_sym(sym, spec) { + if (sym->required) { + ERROR("%ls could not be loaded!", spec->name); + return WIMLIB_ERR_UNSUPPORTED; + } + } + return 0; + } + for_each_sym(sym, spec) { + addr = (void *)GetProcAddress(spec->handle, sym->name); + if (addr) { + *(sym->func_ptr) = addr; + } else if (sym->required) { + ERROR("Can't find %s in %ls", sym->name, spec->name); + return WIMLIB_ERR_UNSUPPORTED; + } + } + return 0; +} + +static void +cleanup_dll(struct dll_spec *spec) { - return windows_version_info.dwMajorVersion > major || - (windows_version_info.dwMajorVersion == major && - windows_version_info.dwMinorVersion >= minor); + const struct dll_sym *sym; + + if (spec->handle) { + FreeLibrary(spec->handle); + spec->handle = NULL; + + for_each_sym(sym, spec) + *(sym->func_ptr) = NULL; + } } /* One-time initialization for Windows capture/apply code. */ int win32_global_init(int init_flags) { + int ret; + /* Try to acquire useful privileges. */ if (!(init_flags & WIMLIB_INIT_FLAG_DONT_ACQUIRE_PRIVILEGES)) { + ret = WIMLIB_ERR_INSUFFICIENT_PRIVILEGES; if (!win32_modify_capture_privileges(true)) if (init_flags & WIMLIB_INIT_FLAG_STRICT_CAPTURE_PRIVILEGES) - goto insufficient_privileges; + goto out_drop_privs; if (!win32_modify_apply_privileges(true)) if (init_flags & WIMLIB_INIT_FLAG_STRICT_APPLY_PRIVILEGES) - goto insufficient_privileges; + goto out_drop_privs; acquired_privileges = true; } - /* Get Windows version information. */ - GetVersionEx(&windows_version_info); - - /* Try to dynamically load some functions. */ - if (hKernel32 == NULL) - hKernel32 = LoadLibrary(L"Kernel32.dll"); - - if (hKernel32) { - win32func_FindFirstStreamW = (void*)GetProcAddress(hKernel32, - "FindFirstStreamW"); - if (win32func_FindFirstStreamW) { - win32func_FindNextStreamW = (void*)GetProcAddress(hKernel32, - "FindNextStreamW"); - if (!win32func_FindNextStreamW) - win32func_FindFirstStreamW = NULL; - } - win32func_CreateSymbolicLinkW = (void*)GetProcAddress(hKernel32, - "CreateSymbolicLinkW"); - } + ret = init_dll(&ntdll_spec); + if (ret) + goto out_drop_privs; -#ifdef WITH_NTDLL - if (hNtdll == NULL) - hNtdll = LoadLibrary(L"ntdll.dll"); + return 0; - if (hNtdll) { - func_RtlNtStatusToDosError = - (void*)GetProcAddress(hNtdll, "RtlNtStatusToDosError"); - if (func_RtlNtStatusToDosError) { +out_drop_privs: + win32_release_capture_and_apply_privileges(); + return ret; +} - func_NtQuerySecurityObject = - (void*)GetProcAddress(hNtdll, "NtQuerySecurityObject"); +void +win32_global_cleanup(void) +{ + if (acquired_privileges) + win32_release_capture_and_apply_privileges(); - func_NtQueryDirectoryFile = - (void*)GetProcAddress(hNtdll, "NtQueryDirectoryFile"); + cleanup_dll(&ntdll_spec); +} - func_NtQueryInformationFile = - (void*)GetProcAddress(hNtdll, "NtQueryInformationFile"); +/* + * Translates a Win32-namespace path into an NT-namespace path. + * + * On success, returns 0. The NT-namespace path will be stored in the + * UNICODE_STRING structure pointed to by nt_path. nt_path->Buffer will be set + * to a new buffer that must later be freed with HeapFree(). (Really + * RtlHeapFree(), but HeapFree() seems to be the same thing.) + * + * On failure, returns WIMLIB_ERR_NOMEM or WIMLIB_ERR_INVALID_PARAM. + */ +int +win32_path_to_nt_path(const wchar_t *win32_path, UNICODE_STRING *nt_path) +{ + NTSTATUS status; - func_NtSetSecurityObject = - (void*)GetProcAddress(hNtdll, "NtSetSecurityObject"); - } + if (func_RtlDosPathNameToNtPathName_U_WithStatus) { + status = (*func_RtlDosPathNameToNtPathName_U_WithStatus)(win32_path, + nt_path, + NULL, NULL); + } else { + if ((*func_RtlDosPathNameToNtPathName_U)(win32_path, nt_path, + NULL, NULL)) + status = STATUS_SUCCESS; + else + status = STATUS_NO_MEMORY; } - DEBUG("FindFirstStreamW @ %p", win32func_FindFirstStreamW); - DEBUG("FindNextStreamW @ %p", win32func_FindNextStreamW); - DEBUG("CreateSymbolicLinkW @ %p", win32func_CreateSymbolicLinkW); - DEBUG("RtlNtStatusToDosError @ %p", func_RtlNtStatusToDosError); - DEBUG("NtQuerySecurityObject @ %p", func_NtQuerySecurityObject); - DEBUG("NtQueryDirectoryFile @ %p", func_NtQueryDirectoryFile); - DEBUG("NtQueryInformationFile @ %p", func_NtQueryInformationFile); - DEBUG("NtSetSecurityObject @ %p", func_NtSetSecurityObject); -#endif + if (likely(NT_SUCCESS(status))) + return 0; - return 0; + if (status == STATUS_NO_MEMORY) + return WIMLIB_ERR_NOMEM; -insufficient_privileges: - win32_release_capture_and_apply_privileges(); - return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES; + ERROR("\"%ls\": invalid path name (status=0x%08"PRIx32")", + win32_path, (u32)status); + return WIMLIB_ERR_INVALID_PARAM; } -void -win32_global_cleanup(void) +int +win32_get_drive_path(const wchar_t *file_path, wchar_t drive_path[7]) { - if (acquired_privileges) - win32_release_capture_and_apply_privileges(); - if (hKernel32 != NULL) { - FreeLibrary(hKernel32); - hKernel32 = NULL; - } -#ifdef WITH_NTDLL - if (hNtdll != NULL) { - FreeLibrary(hNtdll); - hNtdll = NULL; + tchar *file_abspath; + + file_abspath = realpath(file_path, NULL); + if (!file_abspath) + return WIMLIB_ERR_NOMEM; + + if (file_abspath[0] == L'\0' || file_abspath[1] != L':') { + ERROR("\"%ls\": Path format not recognized", file_abspath); + FREE(file_abspath); + return WIMLIB_ERR_UNSUPPORTED; } -#endif + + wsprintf(drive_path, L"\\\\.\\%lc:", file_abspath[0]); + FREE(file_abspath); + return 0; } + #endif /* __WIN32__ */