X-Git-Url: https://wimlib.net/git/?p=wimlib;a=blobdiff_plain;f=src%2Fwin32_common.c;h=3b0d9e842978f04ed354670e31760a0e585c7a85;hp=c347a965030b33eb430b8ec6c01a5a73c42b136b;hb=0ae7e5538476723feb14f07a478b92210e24a21b;hpb=c7616d0c686267ff9556f93e0501940bffd0679c

diff --git a/src/win32_common.c b/src/win32_common.c
index c347a965..3b0d9e84 100644
--- a/src/win32_common.c
+++ b/src/win32_common.c
@@ -3,22 +3,20 @@
  */
 
 /*
- * Copyright (C) 2013 Eric Biggers
+ * Copyright (C) 2013, 2014, 2015 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__
@@ -27,429 +25,11 @@
 #  include "config.h"
 #endif
 
-#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
-win32_error_to_errno(DWORD err_code)
-{
-	/* This mapping is that used in Cygwin.
-	 * Some of these choices are arbitrary. */
-	switch (err_code) {
-	case ERROR_ACCESS_DENIED:
-		return EACCES;
-	case ERROR_ACTIVE_CONNECTIONS:
-		return EAGAIN;
-	case ERROR_ALREADY_EXISTS:
-		return EEXIST;
-	case ERROR_BAD_DEVICE:
-		return ENODEV;
-	case ERROR_BAD_EXE_FORMAT:
-		return ENOEXEC;
-	case ERROR_BAD_NETPATH:
-		return ENOENT;
-	case ERROR_BAD_NET_NAME:
-		return ENOENT;
-	case ERROR_BAD_NET_RESP:
-		return ENOSYS;
-	case ERROR_BAD_PATHNAME:
-		return ENOENT;
-	case ERROR_BAD_PIPE:
-		return EINVAL;
-	case ERROR_BAD_UNIT:
-		return ENODEV;
-	case ERROR_BAD_USERNAME:
-		return EINVAL;
-	case ERROR_BEGINNING_OF_MEDIA:
-		return EIO;
-	case ERROR_BROKEN_PIPE:
-		return EPIPE;
-	case ERROR_BUSY:
-		return EBUSY;
-	case ERROR_BUS_RESET:
-		return EIO;
-	case ERROR_CALL_NOT_IMPLEMENTED:
-		return ENOSYS;
-	case ERROR_CANNOT_MAKE:
-		return EPERM;
-	case ERROR_CHILD_NOT_COMPLETE:
-		return EBUSY;
-	case ERROR_COMMITMENT_LIMIT:
-		return EAGAIN;
-	case ERROR_CRC:
-		return EIO;
-	case ERROR_DEVICE_DOOR_OPEN:
-		return EIO;
-	case ERROR_DEVICE_IN_USE:
-		return EAGAIN;
-	case ERROR_DEVICE_REQUIRES_CLEANING:
-		return EIO;
-	case ERROR_DIRECTORY:
-		return ENOTDIR;
-	case ERROR_DIR_NOT_EMPTY:
-		return ENOTEMPTY;
-	case ERROR_DISK_CORRUPT:
-		return EIO;
-	case ERROR_DISK_FULL:
-		return ENOSPC;
-#ifdef ENOTUNIQ
-	case ERROR_DUP_NAME:
-		return ENOTUNIQ;
-#endif
-	case ERROR_EAS_DIDNT_FIT:
-		return ENOSPC;
-#ifdef ENOTSUP
-	case ERROR_EAS_NOT_SUPPORTED:
-		return ENOTSUP;
-#endif
-	case ERROR_EA_LIST_INCONSISTENT:
-		return EINVAL;
-	case ERROR_EA_TABLE_FULL:
-		return ENOSPC;
-	case ERROR_END_OF_MEDIA:
-		return ENOSPC;
-	case ERROR_EOM_OVERFLOW:
-		return EIO;
-	case ERROR_EXE_MACHINE_TYPE_MISMATCH:
-		return ENOEXEC;
-	case ERROR_EXE_MARKED_INVALID:
-		return ENOEXEC;
-	case ERROR_FILEMARK_DETECTED:
-		return EIO;
-	case ERROR_FILENAME_EXCED_RANGE:
-		return ENAMETOOLONG;
-	case ERROR_FILE_CORRUPT:
-		return EEXIST;
-	case ERROR_FILE_EXISTS:
-		return EEXIST;
-	case ERROR_FILE_INVALID:
-		return ENXIO;
-	case ERROR_FILE_NOT_FOUND:
-		return ENOENT;
-	case ERROR_HANDLE_DISK_FULL:
-		return ENOSPC;
-#ifdef ENODATA
-	case ERROR_HANDLE_EOF:
-		return ENODATA;
-#endif
-	case ERROR_INVALID_ADDRESS:
-		return EINVAL;
-	case ERROR_INVALID_AT_INTERRUPT_TIME:
-		return EINTR;
-	case ERROR_INVALID_BLOCK_LENGTH:
-		return EIO;
-	case ERROR_INVALID_DATA:
-		return EINVAL;
-	case ERROR_INVALID_DRIVE:
-		return ENODEV;
-	case ERROR_INVALID_EA_NAME:
-		return EINVAL;
-	case ERROR_INVALID_EXE_SIGNATURE:
-		return ENOEXEC;
-#ifdef EBADRQC
-	case ERROR_INVALID_FUNCTION:
-		return EBADRQC;
-#endif
-	case ERROR_INVALID_HANDLE:
-		return EBADF;
-	case ERROR_INVALID_NAME:
-		return ENOENT;
-	case ERROR_INVALID_PARAMETER:
-		return EINVAL;
-	case ERROR_INVALID_SIGNAL_NUMBER:
-		return EINVAL;
-	case ERROR_IOPL_NOT_ENABLED:
-		return ENOEXEC;
-	case ERROR_IO_DEVICE:
-		return EIO;
-	case ERROR_IO_INCOMPLETE:
-		return EAGAIN;
-	case ERROR_IO_PENDING:
-		return EAGAIN;
-	case ERROR_LOCK_VIOLATION:
-		return EBUSY;
-	case ERROR_MAX_THRDS_REACHED:
-		return EAGAIN;
-	case ERROR_META_EXPANSION_TOO_LONG:
-		return EINVAL;
-	case ERROR_MOD_NOT_FOUND:
-		return ENOENT;
-#ifdef EMSGSIZE
-	case ERROR_MORE_DATA:
-		return EMSGSIZE;
-#endif
-	case ERROR_NEGATIVE_SEEK:
-		return EINVAL;
-	case ERROR_NETNAME_DELETED:
-		return ENOENT;
-	case ERROR_NOACCESS:
-		return EFAULT;
-	case ERROR_NONE_MAPPED:
-		return EINVAL;
-	case ERROR_NONPAGED_SYSTEM_RESOURCES:
-		return EAGAIN;
-#ifdef ENOLINK
-	case ERROR_NOT_CONNECTED:
-		return ENOLINK;
-#endif
-	case ERROR_NOT_ENOUGH_MEMORY:
-		return ENOMEM;
-	case ERROR_NOT_OWNER:
-		return EPERM;
-#ifdef ENOMEDIUM
-	case ERROR_NOT_READY:
-		return ENOMEDIUM;
-#endif
-	case ERROR_NOT_SAME_DEVICE:
-		return EXDEV;
-	case ERROR_NOT_SUPPORTED:
-		return ENOSYS;
-	case ERROR_NO_DATA:
-		return EPIPE;
-	case ERROR_NO_DATA_DETECTED:
-		return EIO;
-#ifdef ENOMEDIUM
-	case ERROR_NO_MEDIA_IN_DRIVE:
-		return ENOMEDIUM;
-#endif
-#ifdef ENMFILE
-	case ERROR_NO_MORE_FILES:
-		return ENMFILE;
-#endif
-#ifdef ENMFILE
-	case ERROR_NO_MORE_ITEMS:
-		return ENMFILE;
-#endif
-	case ERROR_NO_MORE_SEARCH_HANDLES:
-		return ENFILE;
-	case ERROR_NO_PROC_SLOTS:
-		return EAGAIN;
-	case ERROR_NO_SIGNAL_SENT:
-		return EIO;
-	case ERROR_NO_SYSTEM_RESOURCES:
-		return EFBIG;
-	case ERROR_NO_TOKEN:
-		return EINVAL;
-	case ERROR_OPEN_FAILED:
-		return EIO;
-	case ERROR_OPEN_FILES:
-		return EAGAIN;
-	case ERROR_OUTOFMEMORY:
-		return ENOMEM;
-	case ERROR_PAGED_SYSTEM_RESOURCES:
-		return EAGAIN;
-	case ERROR_PAGEFILE_QUOTA:
-		return EAGAIN;
-	case ERROR_PATH_NOT_FOUND:
-		return ENOENT;
-	case ERROR_PIPE_BUSY:
-		return EBUSY;
-	case ERROR_PIPE_CONNECTED:
-		return EBUSY;
-#ifdef ECOMM
-	case ERROR_PIPE_LISTENING:
-		return ECOMM;
-	case ERROR_PIPE_NOT_CONNECTED:
-		return ECOMM;
-#endif
-	case ERROR_POSSIBLE_DEADLOCK:
-		return EDEADLOCK;
-	case ERROR_PRIVILEGE_NOT_HELD:
-		return EPERM;
-	case ERROR_PROCESS_ABORTED:
-		return EFAULT;
-	case ERROR_PROC_NOT_FOUND:
-		return ESRCH;
-#ifdef ENONET
-	case ERROR_REM_NOT_LIST:
-		return ENONET;
-#endif
-	case ERROR_SECTOR_NOT_FOUND:
-		return EINVAL;
-	case ERROR_SEEK:
-		return EINVAL;
-	case ERROR_SETMARK_DETECTED:
-		return EIO;
-	case ERROR_SHARING_BUFFER_EXCEEDED:
-		return ENOLCK;
-	case ERROR_SHARING_VIOLATION:
-		return EBUSY;
-	case ERROR_SIGNAL_PENDING:
-		return EBUSY;
-	case ERROR_SIGNAL_REFUSED:
-		return EIO;
-#ifdef ELIBBAD
-	case ERROR_SXS_CANT_GEN_ACTCTX:
-		return ELIBBAD;
-#endif
-	case ERROR_THREAD_1_INACTIVE:
-		return EINVAL;
-	case ERROR_TOO_MANY_LINKS:
-		return EMLINK;
-	case ERROR_TOO_MANY_OPEN_FILES:
-		return EMFILE;
-	case ERROR_WAIT_NO_CHILDREN:
-		return ECHILD;
-	case ERROR_WORKING_SET_QUOTA:
-		return EAGAIN;
-	case ERROR_WRITE_PROTECT:
-		return EROFS;
-	default:
-		return -1;
-	}
-}
-
-void
-set_errno_from_GetLastError(void)
-{
-	errno = win32_error_to_errno(GetLastError());
-}
-
-/* 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) {
-		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;
-}
-
 static bool
 win32_modify_privilege(const wchar_t *privilege, bool enable)
 {
@@ -482,16 +62,21 @@ out:
 static bool
 win32_modify_capture_privileges(bool enable)
 {
-	return win32_modify_privilege(SE_BACKUP_NAME, enable)
-	    && win32_modify_privilege(SE_SECURITY_NAME, enable);
+	bool ok = true;
+	ok &= win32_modify_privilege(SE_BACKUP_NAME, enable);
+	ok &= win32_modify_privilege(SE_SECURITY_NAME, enable);
+	return ok;
 }
 
 static bool
 win32_modify_apply_privileges(bool enable)
 {
-	return win32_modify_privilege(SE_RESTORE_NAME, enable)
-	    && win32_modify_privilege(SE_SECURITY_NAME, enable)
-	    && win32_modify_privilege(SE_TAKE_OWNERSHIP_NAME, enable);
+	bool ok = true;
+	ok &= win32_modify_privilege(SE_RESTORE_NAME, enable);
+	ok &= win32_modify_privilege(SE_SECURITY_NAME, enable);
+	ok &= win32_modify_privilege(SE_TAKE_OWNERSHIP_NAME, enable);
+	ok &= win32_modify_privilege(SE_MANAGE_VOLUME_NAME, enable);
+	return ok;
 }
 
 static void
@@ -501,99 +86,231 @@ 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 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);
-}
-
-/* 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. */
+static bool acquired_privileges = false;
 
-/* Vista and later */
-HANDLE (WINAPI *win32func_FindFirstStreamW)(LPCWSTR lpFileName,
-					    STREAM_INFO_LEVELS InfoLevel,
-					    LPVOID lpFindStreamData,
-					    DWORD dwFlags) = NULL;
+struct dll_sym {
+	void **func_ptr;
+	const char *name;
+	bool required;
+};
 
-/* Vista and later */
-BOOL (WINAPI *win32func_FindNextStreamW)(HANDLE hFindStream,
-					 LPVOID lpFindStreamData) = NULL;
+#define DLL_SYM(name, required) { (void **)&func_##name, #name, required }
 
-/* Vista and later */
-BOOL (WINAPI *win32func_CreateSymbolicLinkW)(const wchar_t *lpSymlinkFileName,
-					     const wchar_t *lpTargetFileName,
-					     DWORD dwFlags) = 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;
-		}
-		win32func_CreateSymbolicLinkW = (void*)GetProcAddress(hKernel32,
-								      "CreateSymbolicLinkW");
-	}
+	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
@@ -601,10 +318,209 @@ win32_global_cleanup(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;
+
+	winnt_error(status, L"\"%ls\": invalid path name", win32_path);
+	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;
+}
+
+/* Try to attach an instance of the Windows Overlay File System Filter Driver to
+ * the specified drive (such as C:)  */
+bool
+win32_try_to_attach_wof(const wchar_t *drive)
+{
+	HMODULE fltlib;
+	bool retval = false;
+
+	/* Use FilterAttach() from Fltlib.dll.  */
+
+	fltlib = LoadLibrary(L"Fltlib.dll");
+
+	if (!fltlib) {
+		WARNING("Failed to load Fltlib.dll");
+		return retval;
+	}
+
+	HRESULT (WINAPI *func_FilterAttach)(LPCWSTR lpFilterName,
+					    LPCWSTR lpVolumeName,
+					    LPCWSTR lpInstanceName,
+					    DWORD dwCreatedInstanceNameLength,
+					    LPWSTR lpCreatedInstanceName);
+
+	func_FilterAttach = (void *)GetProcAddress(fltlib, "FilterAttach");
+
+	if (func_FilterAttach) {
+		HRESULT res;
+
+		res = (*func_FilterAttach)(L"WoF", drive, NULL, 0, NULL);
+
+		if (res == S_OK)
+			retval = true;
+	} else {
+		WARNING("FilterAttach() does not exist in Fltlib.dll");
 	}
+
+	FreeLibrary(fltlib);
+
+	return retval;
+}
+
+
+static void
+windows_msg(u32 code, const wchar_t *format, va_list va,
+	    bool is_ntstatus, bool is_error)
+{
+	wchar_t _buf[STACK_MAX / 8];
+	wchar_t *buf = _buf;
+	size_t buflen = ARRAY_LEN(_buf);
+	size_t ret;
+	size_t n;
+
+retry:
+	n = vsnwprintf(buf, buflen, format, va);
+
+	if (n >= buflen)
+		goto realloc;
+
+	n += snwprintf(&buf[n], buflen - n,
+		       (is_ntstatus ?
+			L" (status=%08"PRIx32"): " :
+			L" (err=%"PRIu32"): "),
+		       code);
+
+	if (n >= buflen)
+		goto realloc;
+
+	ret = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+			    NULL,
+			    is_ntstatus ? (*func_RtlNtStatusToDosError)(code) : code,
+			    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			    &buf[n],
+			    buflen - n,
+			    NULL);
+	n += ret;
+
+	if (n >= buflen || (ret == 0 && GetLastError() == ERROR_INSUFFICIENT_BUFFER))
+		goto realloc;
+
+        if (buf[n - 1] == L'\n')
+		buf[--n] = L'\0';
+        if (buf[n - 1] == L'\r')
+		buf[--n] = L'\0';
+        if (buf[n - 1] == L'.')
+		buf[--n] = L'\0';
+
+	if (is_error)
+		ERROR("%ls", buf);
+	else
+		WARNING("%ls", buf);
+	if (buf != _buf)
+		FREE(buf);
+	return;
+
+realloc:
+	if (buf != _buf)
+		FREE(buf);
+	buflen *= 2;
+	buf = MALLOC(buflen * sizeof(buf[0]));
+	if (buf)
+		goto retry;
+	ERROR("Ran out of memory while building error message!!!");
+}
+
+void
+win32_warning(DWORD err, const wchar_t *format, ...)
+{
+	va_list va;
+
+	va_start(va, format);
+	windows_msg(err, format, va, false, false);
+	va_end(va);
+}
+
+void
+win32_error(DWORD err, const wchar_t *format, ...)
+{
+	va_list va;
+
+	va_start(va, format);
+	windows_msg(err, format, va, false, true);
+	va_end(va);
+}
+
+void
+winnt_warning(NTSTATUS status, const wchar_t *format, ...)
+{
+	va_list va;
+
+	va_start(va, format);
+	windows_msg(status, format, va, true, false);
+	va_end(va);
+}
+
+void
+winnt_error(NTSTATUS status, const wchar_t *format, ...)
+{
+	va_list va;
+
+	va_start(va, format);
+	windows_msg(status, format, va, true, true);
+	va_end(va);
 }
 
 #endif /* __WIN32__ */