628f1f0bb7ebd8284b81876970c2c258f2b8580e
[wimlib] / src / win32_common.c
1 /*
2  * win32_common.c - Windows code common to applying and capturing images.
3  */
4
5 /*
6  * Copyright (C) 2013-2016 Eric Biggers
7  *
8  * This file is free software; you can redistribute it and/or modify it under
9  * the terms of the GNU Lesser General Public License as published by the Free
10  * Software Foundation; either version 3 of the License, or (at your option) any
11  * later version.
12  *
13  * This file is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
16  * details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this file; if not, see http://www.gnu.org/licenses/.
20  */
21
22 #ifdef __WIN32__
23
24 #ifdef HAVE_CONFIG_H
25 #  include "config.h"
26 #endif
27
28 #include "wimlib/win32_common.h"
29
30 #include "wimlib/assert.h"
31 #include "wimlib/error.h"
32 #include "wimlib/util.h"
33 #include "wimlib/win32_vss.h"
34
35 static bool
36 win32_modify_privilege(const wchar_t *privilege, bool enable)
37 {
38         HANDLE hToken;
39         LUID luid;
40         TOKEN_PRIVILEGES newState;
41         bool ret = FALSE;
42
43         if (!OpenProcessToken(GetCurrentProcess(),
44                               TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
45                               &hToken))
46                 goto out;
47
48         if (!LookupPrivilegeValue(NULL, privilege, &luid))
49                 goto out_close_handle;
50
51         newState.PrivilegeCount = 1;
52         newState.Privileges[0].Luid = luid;
53         newState.Privileges[0].Attributes = (enable ? SE_PRIVILEGE_ENABLED : 0);
54         SetLastError(ERROR_SUCCESS);
55         ret = AdjustTokenPrivileges(hToken, FALSE, &newState, 0, NULL, NULL);
56         if (ret && GetLastError() == ERROR_NOT_ALL_ASSIGNED)
57                 ret = FALSE;
58 out_close_handle:
59         CloseHandle(hToken);
60 out:
61         return ret;
62 }
63
64 static bool
65 win32_modify_capture_privileges(bool enable)
66 {
67         bool ok = true;
68         ok &= win32_modify_privilege(SE_BACKUP_NAME, enable);
69         ok &= win32_modify_privilege(SE_SECURITY_NAME, enable);
70         return ok;
71 }
72
73 static bool
74 win32_modify_apply_privileges(bool enable)
75 {
76         bool ok = true;
77         ok &= win32_modify_privilege(SE_RESTORE_NAME, enable);
78         ok &= win32_modify_privilege(SE_SECURITY_NAME, enable);
79         ok &= win32_modify_privilege(SE_TAKE_OWNERSHIP_NAME, enable);
80         ok &= win32_modify_privilege(SE_MANAGE_VOLUME_NAME, enable);
81         return ok;
82 }
83
84 static void
85 win32_release_capture_and_apply_privileges(void)
86 {
87         win32_modify_capture_privileges(false);
88         win32_modify_apply_privileges(false);
89 }
90
91 /* Pointers to dynamically loaded functions  */
92
93 /* ntdll.dll  */
94
95 NTSTATUS (WINAPI *func_NtCreateFile)(PHANDLE FileHandle,
96                                      ACCESS_MASK DesiredAccess,
97                                      POBJECT_ATTRIBUTES ObjectAttributes,
98                                      PIO_STATUS_BLOCK IoStatusBlock,
99                                      PLARGE_INTEGER AllocationSize,
100                                      ULONG FileAttributes,
101                                      ULONG ShareAccess,
102                                      ULONG CreateDisposition,
103                                      ULONG CreateOptions,
104                                      PVOID EaBuffer,
105                                      ULONG EaLength);
106
107 NTSTATUS (WINAPI *func_NtOpenFile) (PHANDLE FileHandle,
108                                     ACCESS_MASK DesiredAccess,
109                                     POBJECT_ATTRIBUTES ObjectAttributes,
110                                     PIO_STATUS_BLOCK IoStatusBlock,
111                                     ULONG ShareAccess,
112                                     ULONG OpenOptions);
113
114 NTSTATUS (WINAPI *func_NtReadFile) (HANDLE FileHandle,
115                                     HANDLE Event,
116                                     PIO_APC_ROUTINE ApcRoutine,
117                                     PVOID ApcContext,
118                                     PIO_STATUS_BLOCK IoStatusBlock,
119                                     PVOID Buffer,
120                                     ULONG Length,
121                                     PLARGE_INTEGER ByteOffset,
122                                     PULONG Key);
123
124 NTSTATUS (WINAPI *func_NtWriteFile) (HANDLE FileHandle,
125                                      HANDLE Event,
126                                      PIO_APC_ROUTINE ApcRoutine,
127                                      PVOID ApcContext,
128                                      PIO_STATUS_BLOCK IoStatusBlock,
129                                      PVOID Buffer,
130                                      ULONG Length,
131                                      PLARGE_INTEGER ByteOffset,
132                                      PULONG Key);
133
134 NTSTATUS (WINAPI *func_NtQueryInformationFile)(HANDLE FileHandle,
135                                                PIO_STATUS_BLOCK IoStatusBlock,
136                                                PVOID FileInformation,
137                                                ULONG Length,
138                                                FILE_INFORMATION_CLASS FileInformationClass);
139
140 NTSTATUS (WINAPI *func_NtQuerySecurityObject)(HANDLE handle,
141                                               SECURITY_INFORMATION SecurityInformation,
142                                               PSECURITY_DESCRIPTOR SecurityDescriptor,
143                                               ULONG Length,
144                                               PULONG LengthNeeded);
145
146 NTSTATUS (WINAPI *func_NtQueryDirectoryFile) (HANDLE FileHandle,
147                                               HANDLE Event,
148                                               PIO_APC_ROUTINE ApcRoutine,
149                                               PVOID ApcContext,
150                                               PIO_STATUS_BLOCK IoStatusBlock,
151                                               PVOID FileInformation,
152                                               ULONG Length,
153                                               FILE_INFORMATION_CLASS FileInformationClass,
154                                               BOOLEAN ReturnSingleEntry,
155                                               PUNICODE_STRING FileName,
156                                               BOOLEAN RestartScan);
157
158 NTSTATUS (WINAPI *func_NtQueryVolumeInformationFile) (HANDLE FileHandle,
159                                                       PIO_STATUS_BLOCK IoStatusBlock,
160                                                       PVOID FsInformation,
161                                                       ULONG Length,
162                                                       FS_INFORMATION_CLASS FsInformationClass);
163
164 NTSTATUS (WINAPI *func_NtSetInformationFile)(HANDLE FileHandle,
165                                              PIO_STATUS_BLOCK IoStatusBlock,
166                                              PVOID FileInformation,
167                                              ULONG Length,
168                                              FILE_INFORMATION_CLASS FileInformationClass);
169
170 NTSTATUS (WINAPI *func_NtSetSecurityObject)(HANDLE Handle,
171                                             SECURITY_INFORMATION SecurityInformation,
172                                             PSECURITY_DESCRIPTOR SecurityDescriptor);
173
174 static NTSTATUS (WINAPI *func_NtFsControlFile) (HANDLE FileHandle,
175                                                 HANDLE Event,
176                                                 PIO_APC_ROUTINE ApcRoutine,
177                                                 PVOID ApcContext,
178                                                 PIO_STATUS_BLOCK IoStatusBlock,
179                                                 ULONG FsControlCode,
180                                                 PVOID InputBuffer,
181                                                 ULONG InputBufferLength,
182                                                 PVOID OutputBuffer,
183                                                 ULONG OutputBufferLength);
184
185 static NTSTATUS (WINAPI *func_NtWaitForSingleObject) (HANDLE Handle,
186                                                       BOOLEAN Alertable,
187                                                       PLARGE_INTEGER Timeout);
188
189 NTSTATUS (WINAPI *func_NtClose) (HANDLE Handle);
190
191 DWORD (WINAPI *func_RtlNtStatusToDosError)(NTSTATUS status);
192
193 BOOLEAN (WINAPI *func_RtlDosPathNameToNtPathName_U)
194                   (IN PCWSTR DosName,
195                    OUT PUNICODE_STRING NtName,
196                    OUT PCWSTR *PartName,
197                    OUT PRTL_RELATIVE_NAME_U RelativeName);
198
199 NTSTATUS (WINAPI *func_RtlDosPathNameToNtPathName_U_WithStatus)
200                 (IN PCWSTR DosName,
201                  OUT PUNICODE_STRING NtName,
202                  OUT PCWSTR *PartName,
203                  OUT PRTL_RELATIVE_NAME_U RelativeName);
204
205 NTSTATUS (WINAPI *func_RtlCreateSystemVolumeInformationFolder)
206                 (PCUNICODE_STRING VolumeRootPath);
207
208 static bool acquired_privileges = false;
209
210 struct dll_sym {
211         void **func_ptr;
212         const char *name;
213         bool required;
214 };
215
216 #define DLL_SYM(name, required) { (void **)&func_##name, #name, required }
217
218 #define for_each_sym(sym, spec) \
219         for ((sym) = (spec)->syms; (sym)->name; (sym)++)
220
221 struct dll_spec {
222         const wchar_t *name;
223         HMODULE handle;
224         const struct dll_sym syms[];
225 };
226
227 struct dll_spec ntdll_spec = {
228         .name = L"ntdll.dll",
229         .syms = {
230                 DLL_SYM(NtCreateFile, true),
231                 DLL_SYM(NtOpenFile, true),
232                 DLL_SYM(NtReadFile, true),
233                 DLL_SYM(NtWriteFile, true),
234                 DLL_SYM(NtQueryInformationFile, true),
235                 DLL_SYM(NtQuerySecurityObject, true),
236                 DLL_SYM(NtQueryDirectoryFile, true),
237                 DLL_SYM(NtQueryVolumeInformationFile, true),
238                 DLL_SYM(NtSetInformationFile, true),
239                 DLL_SYM(NtSetSecurityObject, true),
240                 DLL_SYM(NtFsControlFile, true),
241                 DLL_SYM(NtWaitForSingleObject, true),
242                 DLL_SYM(NtClose, true),
243                 DLL_SYM(RtlNtStatusToDosError, true),
244                 DLL_SYM(RtlCreateSystemVolumeInformationFolder, false),
245                 DLL_SYM(RtlDosPathNameToNtPathName_U, true),
246                 DLL_SYM(RtlDosPathNameToNtPathName_U_WithStatus, false), /* Not present on XP  */
247                 {NULL, NULL},
248         },
249 };
250
251 static int
252 init_dll(struct dll_spec *spec)
253 {
254         const struct dll_sym *sym;
255         void *addr;
256
257         if (!spec->handle)
258                 spec->handle = LoadLibrary(spec->name);
259         if (!spec->handle) {
260                 for_each_sym(sym, spec) {
261                         if (sym->required) {
262                                 ERROR("%ls could not be loaded!", spec->name);
263                                 return WIMLIB_ERR_UNSUPPORTED;
264                         }
265                 }
266                 return 0;
267         }
268         for_each_sym(sym, spec) {
269                 addr = (void *)GetProcAddress(spec->handle, sym->name);
270                 if (addr) {
271                         *(sym->func_ptr) = addr;
272                 } else if (sym->required) {
273                         ERROR("Can't find %s in %ls", sym->name, spec->name);
274                         return WIMLIB_ERR_UNSUPPORTED;
275                 }
276         }
277         return 0;
278 }
279
280 static void
281 cleanup_dll(struct dll_spec *spec)
282 {
283         const struct dll_sym *sym;
284
285         if (spec->handle) {
286                 FreeLibrary(spec->handle);
287                 spec->handle = NULL;
288
289                 for_each_sym(sym, spec)
290                         *(sym->func_ptr) = NULL;
291         }
292 }
293
294 /* One-time initialization for Windows capture/apply code.  */
295 int
296 win32_global_init(int init_flags)
297 {
298         int ret;
299
300         /* Try to acquire useful privileges.  */
301         if (!(init_flags & WIMLIB_INIT_FLAG_DONT_ACQUIRE_PRIVILEGES)) {
302                 ret = WIMLIB_ERR_INSUFFICIENT_PRIVILEGES;
303                 if (!win32_modify_capture_privileges(true))
304                         if (init_flags & WIMLIB_INIT_FLAG_STRICT_CAPTURE_PRIVILEGES)
305                                 goto out_drop_privs;
306                 if (!win32_modify_apply_privileges(true))
307                         if (init_flags & WIMLIB_INIT_FLAG_STRICT_APPLY_PRIVILEGES)
308                                 goto out_drop_privs;
309                 acquired_privileges = true;
310         }
311
312         ret = init_dll(&ntdll_spec);
313         if (ret)
314                 goto out_drop_privs;
315
316         return 0;
317
318 out_drop_privs:
319         win32_release_capture_and_apply_privileges();
320         return ret;
321 }
322
323 void
324 win32_global_cleanup(void)
325 {
326         vss_global_cleanup();
327
328         if (acquired_privileges)
329                 win32_release_capture_and_apply_privileges();
330
331         cleanup_dll(&ntdll_spec);
332 }
333
334 /*
335  * Translates a Win32-namespace path into an NT-namespace path.
336  *
337  * On success, returns 0.  The NT-namespace path will be stored in the
338  * UNICODE_STRING structure pointed to by nt_path.  nt_path->Buffer will be set
339  * to a new buffer that must later be freed with HeapFree().  (Really
340  * RtlHeapFree(), but HeapFree() seems to be the same thing.)
341  *
342  * On failure, returns WIMLIB_ERR_NOMEM or WIMLIB_ERR_INVALID_PARAM.
343  */
344 int
345 win32_path_to_nt_path(const wchar_t *win32_path, UNICODE_STRING *nt_path)
346 {
347         NTSTATUS status;
348
349         if (func_RtlDosPathNameToNtPathName_U_WithStatus) {
350                 status = (*func_RtlDosPathNameToNtPathName_U_WithStatus)(win32_path,
351                                                                          nt_path,
352                                                                          NULL, NULL);
353         } else {
354                 if ((*func_RtlDosPathNameToNtPathName_U)(win32_path, nt_path,
355                                                          NULL, NULL))
356                         status = STATUS_SUCCESS;
357                 else
358                         status = STATUS_NO_MEMORY;
359         }
360
361         if (likely(NT_SUCCESS(status)))
362                 return 0;
363
364         if (status == STATUS_NO_MEMORY)
365                 return WIMLIB_ERR_NOMEM;
366
367         winnt_error(status, L"\"%ls\": invalid path name", win32_path);
368         return WIMLIB_ERR_INVALID_PARAM;
369 }
370
371 int
372 win32_get_drive_path(const wchar_t *file_path, wchar_t drive_path[7])
373 {
374         tchar *file_abspath;
375
376         file_abspath = realpath(file_path, NULL);
377         if (!file_abspath)
378                 return WIMLIB_ERR_NOMEM;
379
380         if (file_abspath[0] == L'\0' || file_abspath[1] != L':') {
381                 ERROR("\"%ls\": Path format not recognized", file_abspath);
382                 FREE(file_abspath);
383                 return WIMLIB_ERR_UNSUPPORTED;
384         }
385
386         wsprintf(drive_path, L"\\\\.\\%lc:", file_abspath[0]);
387         FREE(file_abspath);
388         return 0;
389 }
390
391 /* Try to attach an instance of the Windows Overlay File System Filter Driver to
392  * the specified drive (such as C:)  */
393 bool
394 win32_try_to_attach_wof(const wchar_t *drive)
395 {
396         HMODULE fltlib;
397         bool retval = false;
398
399         /* Use FilterAttach() from Fltlib.dll.  */
400
401         fltlib = LoadLibrary(L"Fltlib.dll");
402
403         if (!fltlib) {
404                 WARNING("Failed to load Fltlib.dll");
405                 return retval;
406         }
407
408         HRESULT (WINAPI *func_FilterAttach)(LPCWSTR lpFilterName,
409                                             LPCWSTR lpVolumeName,
410                                             LPCWSTR lpInstanceName,
411                                             DWORD dwCreatedInstanceNameLength,
412                                             LPWSTR lpCreatedInstanceName);
413
414         func_FilterAttach = (void *)GetProcAddress(fltlib, "FilterAttach");
415
416         if (func_FilterAttach) {
417                 HRESULT res;
418
419                 res = (*func_FilterAttach)(L"wof", drive, NULL, 0, NULL);
420
421                 if (res != S_OK)
422                         res = (*func_FilterAttach)(L"wofadk", drive, NULL, 0, NULL);
423
424                 if (res == S_OK)
425                         retval = true;
426         } else {
427                 WARNING("FilterAttach() does not exist in Fltlib.dll");
428         }
429
430         FreeLibrary(fltlib);
431
432         return retval;
433 }
434
435
436 static void
437 windows_msg(u32 code, const wchar_t *format, va_list va,
438             bool is_ntstatus, bool is_error)
439 {
440         wchar_t _buf[STACK_MAX / 8];
441         wchar_t *buf = _buf;
442         size_t buflen = ARRAY_LEN(_buf);
443         size_t ret;
444         size_t n;
445
446 retry:
447         n = vsnwprintf(buf, buflen, format, va);
448
449         if (n >= buflen)
450                 goto realloc;
451
452         n += snwprintf(&buf[n], buflen - n,
453                        (is_ntstatus ?
454                         L" (status=%08"PRIx32"): " :
455                         L" (err=%"PRIu32"): "),
456                        code);
457
458         if (n >= buflen)
459                 goto realloc;
460
461         ret = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
462                                 FORMAT_MESSAGE_IGNORE_INSERTS |
463                                 (is_ntstatus ? FORMAT_MESSAGE_FROM_HMODULE : 0),
464                             (is_ntstatus ? ntdll_spec.handle : NULL),
465                             code,
466                             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
467                             &buf[n],
468                             buflen - n,
469                             NULL);
470         n += ret;
471
472         if (n >= buflen || (ret == 0 && GetLastError() == ERROR_INSUFFICIENT_BUFFER))
473                 goto realloc;
474
475         if (buf[n - 1] == L'\n')
476                 buf[--n] = L'\0';
477         if (buf[n - 1] == L'\r')
478                 buf[--n] = L'\0';
479         if (buf[n - 1] == L'.')
480                 buf[--n] = L'\0';
481
482         if (is_error)
483                 ERROR("%ls", buf);
484         else
485                 WARNING("%ls", buf);
486         if (buf != _buf)
487                 FREE(buf);
488         return;
489
490 realloc:
491         if (buf != _buf)
492                 FREE(buf);
493         buflen *= 2;
494         buf = MALLOC(buflen * sizeof(buf[0]));
495         if (buf)
496                 goto retry;
497         ERROR("Ran out of memory while building error message!!!");
498 }
499
500 void
501 win32_warning(DWORD err, const wchar_t *format, ...)
502 {
503         va_list va;
504
505         va_start(va, format);
506         windows_msg(err, format, va, false, false);
507         va_end(va);
508 }
509
510 void
511 win32_error(DWORD err, const wchar_t *format, ...)
512 {
513         va_list va;
514
515         va_start(va, format);
516         windows_msg(err, format, va, false, true);
517         va_end(va);
518 }
519
520 void
521 winnt_warning(NTSTATUS status, const wchar_t *format, ...)
522 {
523         va_list va;
524
525         va_start(va, format);
526         windows_msg(status, format, va, true, false);
527         va_end(va);
528 }
529
530 void
531 winnt_error(NTSTATUS status, const wchar_t *format, ...)
532 {
533         va_list va;
534
535         va_start(va, format);
536         windows_msg(status, format, va, true, true);
537         va_end(va);
538 }
539
540 /*
541  * Synchronously execute a filesystem control method.  This is a wrapper around
542  * NtFsControlFile() that handles STATUS_PENDING.  Note that SYNCHRONIZE
543  * permission is, in general, required on the handle.
544  */
545 NTSTATUS
546 winnt_fsctl(HANDLE h, u32 code, const void *in, u32 in_size,
547             void *out, u32 out_size_avail, u32 *actual_out_size_ret)
548 {
549         IO_STATUS_BLOCK iosb;
550         NTSTATUS status;
551
552         status = (*func_NtFsControlFile)(h, NULL, NULL, NULL, &iosb, code,
553                                          (void *)in, in_size,
554                                          out, out_size_avail);
555         if (status == STATUS_PENDING) {
556                 /* Beware: this case is often encountered with remote
557                  * filesystems, but rarely with local filesystems.  */
558
559                 status = (*func_NtWaitForSingleObject)(h, FALSE, NULL);
560                 if (NT_SUCCESS(status)) {
561                         status = iosb.Status;
562                 } else {
563                         /* We shouldn't be issuing ioctls on a handle to which
564                          * we don't have SYNCHRONIZE access.  Otherwise we have
565                          * no way to wait for them to complete.  */
566                         wimlib_assert(status != STATUS_ACCESS_DENIED);
567                 }
568         }
569
570         if (NT_SUCCESS(status) && actual_out_size_ret != NULL)
571                 *actual_out_size_ret = (u32)iosb.Information;
572
573         return status;
574 }
575
576 #endif /* __WIN32__ */