*/
/*
- * 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__
#include <errno.h>
#include "wimlib/win32_common.h"
-
-#include "wimlib/assert.h"
#include "wimlib/error.h"
#include "wimlib/util.h"
-#ifdef ENABLE_ERROR_MESSAGES
-void
-win32_error(DWORD err_code)
-{
- wchar_t *buffer;
- DWORD nchars;
- nchars = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
- FORMAT_MESSAGE_ALLOCATE_BUFFER,
- NULL, err_code, 0,
- (wchar_t*)&buffer, 0, NULL);
- if (nchars == 0) {
- ERROR("Error printing error message! "
- "Computer will self-destruct in 3 seconds.");
- } else {
- ERROR("Win32 error: %ls", buffer);
- LocalFree(buffer);
- }
-}
-#endif /* ENABLE_ERROR_MESSAGES */
-
-int
+static int
win32_error_to_errno(DWORD err_code)
{
/* This mapping is that used in Cygwin.
}
void
-set_errno_from_GetLastError(void)
+set_errno_from_win32_error(DWORD err)
{
- errno = win32_error_to_errno(GetLastError());
+ errno = win32_error_to_errno(err);
}
-/* 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)
+void
+set_errno_from_GetLastError(void)
{
- 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;
+ set_errno_from_win32_error(GetLastError());
}
-bool
-win32_path_is_root_of_drive(const wchar_t *path)
+void
+set_errno_from_nt_status(NTSTATUS status)
{
- 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) {
- DWORD err = GetLastError();
- WARNING("Failed to get volume information for path \"%ls\"", path);
- win32_error(err);
- 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;
+ set_errno_from_win32_error((*func_RtlNtStatusToDosError)(status));
}
static bool
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 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,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass);
+
+NTSTATUS (WINAPI *func_NtQuerySecurityObject)(HANDLE handle,
+ SECURITY_INFORMATION SecurityInformation,
+ PSECURITY_DESCRIPTOR SecurityDescriptor,
+ ULONG Length,
+ PULONG LengthNeeded);
+
+NTSTATUS (WINAPI *func_NtQueryDirectoryFile) (HANDLE FileHandle,
+ HANDLE Event,
+ PIO_APC_ROUTINE ApcRoutine,
+ PVOID ApcContext,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass,
+ BOOLEAN ReturnSingleEntry,
+ 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);
+
+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);
+
+NTSTATUS (WINAPI *func_NtClose) (HANDLE Handle);
+
+DWORD (WINAPI *func_RtlNtStatusToDosError)(NTSTATUS status);
+
+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);
-HANDLE
-win32_open_file_data_only(const wchar_t *path)
-{
- return win32_open_existing_file(path, FILE_READ_DATA);
-}
+static bool acquired_privileges = false;
-/* 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. */
+struct dll_sym {
+ void **func_ptr;
+ const char *name;
+ bool required;
+};
-/* Vista and later */
-HANDLE (WINAPI *win32func_FindFirstStreamW)(LPCWSTR lpFileName,
- STREAM_INFO_LEVELS InfoLevel,
- LPVOID lpFindStreamData,
- DWORD dwFlags) = NULL;
+#define DLL_SYM(name, required) { (void **)&func_##name, #name, required }
-/* Vista and later */
-BOOL (WINAPI *win32func_FindNextStreamW)(HANDLE hFindStream,
- LPVOID lpFindStreamData) = NULL;
+#define for_each_sym(sym, spec) \
+ for ((sym) = (spec)->syms; (sym)->name; (sym)++)
-static OSVERSIONINFO windows_version_info = {
- .dwOSVersionInfoSize = sizeof(OSVERSIONINFO),
+struct dll_spec {
+ const wchar_t *name;
+ HMODULE handle;
+ const struct dll_sym syms[];
};
-static HMODULE hKernel32 = NULL;
+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 bool acquired_privileges = false;
+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;
+}
-bool
-windows_version_is_at_least(unsigned major, unsigned minor)
+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;
- }
- }
+ ret = init_dll(&ntdll_spec);
+ if (ret)
+ goto out_drop_privs;
+
return 0;
-insufficient_privileges:
+out_drop_privs:
win32_release_capture_and_apply_privileges();
- return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES;
+ return ret;
}
void
{
if (acquired_privileges)
win32_release_capture_and_apply_privileges();
- if (hKernel32 != NULL) {
- FreeLibrary(hKernel32);
- hKernel32 = NULL;
+
+ cleanup_dll(&ntdll_spec);
+}
+
+/*
+ * 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;
+
+ 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;
+ }
+
+ if (likely(NT_SUCCESS(status)))
+ return 0;
+
+ if (status == STATUS_NO_MEMORY)
+ return WIMLIB_ERR_NOMEM;
+
+ ERROR("\"%ls\": invalid path name (status=0x%08"PRIx32")",
+ win32_path, (u32)status);
+ return WIMLIB_ERR_INVALID_PARAM;
+}
+
+int
+win32_get_drive_path(const wchar_t *file_path, wchar_t drive_path[7])
+{
+ 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;
}
+
+ wsprintf(drive_path, L"\\\\.\\%lc:", file_abspath[0]);
+ FREE(file_abspath);
+ return 0;
}
+
#endif /* __WIN32__ */