f971ca6f8bdeaf12c0f479832d36706edd1bd83c
[wimlib] / src / win32_apply.c
1 /*
2  * win32_apply.c - Windows-specific code for applying files from a WIM image.
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/apply.h"
31 #include "wimlib/assert.h"
32 #include "wimlib/blob_table.h"
33 #include "wimlib/dentry.h"
34 #include "wimlib/encoding.h"
35 #include "wimlib/error.h"
36 #include "wimlib/metadata.h"
37 #include "wimlib/object_id.h"
38 #include "wimlib/paths.h"
39 #include "wimlib/pattern.h"
40 #include "wimlib/reparse.h"
41 #include "wimlib/scan.h" /* for mangle_pat() and match_pattern_list()  */
42 #include "wimlib/textfile.h"
43 #include "wimlib/xml.h"
44 #include "wimlib/wimboot.h"
45 #include "wimlib/wof.h"
46
47 struct win32_apply_ctx {
48
49         /* Extract flags, the pointer to the WIMStruct, etc.  */
50         struct apply_ctx common;
51
52         /* WIMBoot information, only filled in if WIMLIB_EXTRACT_FLAG_WIMBOOT
53          * was provided  */
54         struct {
55                 /* This array contains the WIM files registered with WOF on the
56                  * target volume for this extraction operation.  All WIMStructs
57                  * in this array are distinct and have ->filename != NULL.  */
58                 struct wimboot_wim {
59                         WIMStruct *wim;
60                         u64 data_source_id;
61                         u8 blob_table_hash[SHA1_HASH_SIZE];
62                 } *wims;
63                 size_t num_wims;
64                 bool wof_running;
65                 bool have_wrong_version_wims;
66                 bool have_uncompressed_wims;
67                 bool have_unsupported_compressed_resources;
68                 bool have_huge_resources;
69         } wimboot;
70
71         /* External backing information  */
72         struct string_list *prepopulate_pats;
73         void *mem_prepopulate_pats;
74         bool tried_to_load_prepopulate_list;
75
76         /* Open handle to the target directory  */
77         HANDLE h_target;
78
79         /* NT namespace path to the target directory (buffer allocated)  */
80         UNICODE_STRING target_ntpath;
81
82         /* Temporary buffer for building paths (buffer allocated)  */
83         UNICODE_STRING pathbuf;
84
85         /* Object attributes to reuse for opening files in the target directory.
86          * (attr.ObjectName == &pathbuf) and (attr.RootDirectory == h_target).
87          */
88         OBJECT_ATTRIBUTES attr;
89
90         /* Temporary I/O status block for system calls  */
91         IO_STATUS_BLOCK iosb;
92
93         /* Allocated buffer for creating "printable" paths from our
94          * target-relative NT paths  */
95         wchar_t *print_buffer;
96
97         /* Allocated buffer for reading blob data when it cannot be extracted
98          * directly  */
99         u8 *data_buffer;
100
101         /* Pointer to the next byte in @data_buffer to fill  */
102         u8 *data_buffer_ptr;
103
104         /* Size allocated in @data_buffer  */
105         size_t data_buffer_size;
106
107         /* Current offset in the raw encrypted file being written  */
108         size_t encrypted_offset;
109
110         /* Current size of the raw encrypted file being written  */
111         size_t encrypted_size;
112
113         /* Temporary buffer for reparse data  */
114         struct reparse_buffer_disk rpbuf;
115
116         /* Temporary buffer for reparse data of "fixed" absolute symbolic links
117          * and junctions  */
118         struct reparse_buffer_disk rpfixbuf;
119
120         /* Array of open handles to filesystem streams currently being written
121          */
122         HANDLE open_handles[MAX_OPEN_FILES];
123
124         /* Number of handles in @open_handles currently open (filled in from the
125          * beginning of the array)  */
126         unsigned num_open_handles;
127
128         /* For each currently open stream, whether we're writing to it in
129          * "sparse" mode or not.  */
130         bool is_sparse_stream[MAX_OPEN_FILES];
131
132         /* Whether is_sparse_stream[] is true for any currently open stream  */
133         bool any_sparse_streams;
134
135         /* List of dentries, joined by @d_tmp_list, that need to have reparse
136          * data extracted as soon as the whole blob has been read into
137          * @data_buffer.  */
138         struct list_head reparse_dentries;
139
140         /* List of dentries, joined by @d_tmp_list, that need to have raw
141          * encrypted data extracted as soon as the whole blob has been read into
142          * @data_buffer.  */
143         struct list_head encrypted_dentries;
144
145         /* Number of files for which we didn't have permission to set the full
146          * security descriptor.  */
147         unsigned long partial_security_descriptors;
148
149         /* Number of files for which we didn't have permission to set any part
150          * of the security descriptor.  */
151         unsigned long no_security_descriptors;
152
153         /* Number of files for which we couldn't set the short name.  */
154         unsigned long num_set_short_name_failures;
155
156         /* Number of files for which we couldn't remove the short name.  */
157         unsigned long num_remove_short_name_failures;
158
159         /* Number of files on which we couldn't set System Compression.  */
160         unsigned long num_system_compression_failures;
161
162         /* The number of files which, for compatibility with the Windows
163          * bootloader, were not compressed using the requested system
164          * compression format.  This includes matches with the hardcoded pattern
165          * list only; it does not include matches with patterns in
166          * [PrepopulateList].  */
167         unsigned long num_system_compression_exclusions;
168
169         /* Number of files for which we couldn't set the object ID.  */
170         unsigned long num_object_id_failures;
171
172         /* The Windows build number of the image being applied, or 0 if unknown.
173          */
174         u64 windows_build_number;
175
176         /* Have we tried to enable short name support on the target volume yet?
177          */
178         bool tried_to_enable_short_names;
179 };
180
181 /* Get the drive letter from a Windows path, or return the null character if the
182  * path is relative.  */
183 static wchar_t
184 get_drive_letter(const wchar_t *path)
185 {
186         /* Skip \\?\ prefix  */
187         if (!wcsncmp(path, L"\\\\?\\", 4))
188                 path += 4;
189
190         /* Return drive letter if valid  */
191         if (((path[0] >= L'a' && path[0] <= L'z') ||
192              (path[0] >= L'A' && path[0] <= L'Z')) && path[1] == L':')
193                 return path[0];
194
195         return L'\0';
196 }
197
198 static void
199 get_vol_flags(const wchar_t *target, DWORD *vol_flags_ret,
200               bool *short_names_supported_ret)
201 {
202         wchar_t filesystem_name[MAX_PATH + 1];
203         wchar_t drive[4];
204         wchar_t *volume = NULL;
205
206         *vol_flags_ret = 0;
207         *short_names_supported_ret = false;
208
209         drive[0] = get_drive_letter(target);
210         if (drive[0]) {
211                 drive[1] = L':';
212                 drive[2] = L'\\';
213                 drive[3] = L'\0';
214                 volume = drive;
215         }
216
217         if (!GetVolumeInformation(volume, NULL, 0, NULL, NULL,
218                                   vol_flags_ret, filesystem_name,
219                                   ARRAY_LEN(filesystem_name)))
220         {
221                 win32_warning(GetLastError(),
222                               L"Failed to get volume information for \"%ls\"",
223                               target);
224                 return;
225         }
226
227         if (wcsstr(filesystem_name, L"NTFS")) {
228                 /* FILE_SUPPORTS_HARD_LINKS is only supported on Windows 7 and
229                  * later.  Force it on anyway if filesystem is NTFS.  */
230                 *vol_flags_ret |= FILE_SUPPORTS_HARD_LINKS;
231
232                 /* There's no volume flag for short names, but according to the
233                  * MS documentation they are only user-settable on NTFS.  */
234                 *short_names_supported_ret = true;
235         }
236 }
237
238 /* Is the image being extracted an OS image for Windows 10 or later?  */
239 static bool
240 is_image_windows_10_or_later(struct win32_apply_ctx *ctx)
241 {
242         /* Note: if no build number is available, this returns false.  */
243         return ctx->windows_build_number >= 10240;
244 }
245
246 static const wchar_t *
247 current_path(struct win32_apply_ctx *ctx);
248
249 static void
250 build_extraction_path(const struct wim_dentry *dentry,
251                       struct win32_apply_ctx *ctx);
252
253 static int
254 report_dentry_apply_error(const struct wim_dentry *dentry,
255                           struct win32_apply_ctx *ctx, int ret)
256 {
257         build_extraction_path(dentry, ctx);
258         return report_apply_error(&ctx->common, ret, current_path(ctx));
259 }
260
261 static inline int
262 check_apply_error(const struct wim_dentry *dentry,
263                   struct win32_apply_ctx *ctx, int ret)
264 {
265         if (unlikely(ret))
266                 ret = report_dentry_apply_error(dentry, ctx, ret);
267         return ret;
268 }
269
270 static int
271 win32_get_supported_features(const wchar_t *target,
272                              struct wim_features *supported_features)
273 {
274         DWORD vol_flags;
275         bool short_names_supported;
276
277         /* Query the features of the target volume.  */
278
279         get_vol_flags(target, &vol_flags, &short_names_supported);
280
281         supported_features->readonly_files = 1;
282         supported_features->hidden_files = 1;
283         supported_features->system_files = 1;
284         supported_features->archive_files = 1;
285
286         if (vol_flags & FILE_FILE_COMPRESSION)
287                 supported_features->compressed_files = 1;
288
289         if (vol_flags & FILE_SUPPORTS_ENCRYPTION) {
290                 supported_features->encrypted_files = 1;
291                 supported_features->encrypted_directories = 1;
292         }
293
294         supported_features->not_context_indexed_files = 1;
295
296         if (vol_flags & FILE_SUPPORTS_SPARSE_FILES)
297                 supported_features->sparse_files = 1;
298
299         if (vol_flags & FILE_NAMED_STREAMS)
300                 supported_features->named_data_streams = 1;
301
302         if (vol_flags & FILE_SUPPORTS_HARD_LINKS)
303                 supported_features->hard_links = 1;
304
305         if (vol_flags & FILE_SUPPORTS_REPARSE_POINTS)
306                 supported_features->reparse_points = 1;
307
308         if (vol_flags & FILE_PERSISTENT_ACLS)
309                 supported_features->security_descriptors = 1;
310
311         if (short_names_supported)
312                 supported_features->short_names = 1;
313
314         if (vol_flags & FILE_SUPPORTS_OBJECT_IDS)
315                 supported_features->object_ids = 1;
316
317         supported_features->timestamps = 1;
318
319         if (vol_flags & FILE_CASE_SENSITIVE_SEARCH) {
320                 /*
321                  * The filesystem supports case-sensitive filenames.  But does
322                  * the operating system as well?  This normally requires the
323                  * registry setting ObCaseInsensitive=0.  We can test it
324                  * indirectly by attempting to open the "\SystemRoot" symbolic
325                  * link using a name with the wrong case.  If we get
326                  * STATUS_OBJECT_NAME_NOT_FOUND instead of STATUS_ACCESS_DENIED,
327                  * then case-sensitive names must be enabled.
328                  */
329                 UNICODE_STRING path;
330                 OBJECT_ATTRIBUTES attr;
331                 HANDLE h;
332                 NTSTATUS status;
333
334                 RtlInitUnicodeString(&path, L"\\systemroot");
335                 InitializeObjectAttributes(&attr, &path, 0, NULL, NULL);
336
337                 status = NtOpenSymbolicLinkObject(&h, 0, &attr);
338                 if (status == STATUS_OBJECT_NAME_NOT_FOUND)
339                         supported_features->case_sensitive_filenames = 1;
340         }
341
342         return 0;
343 }
344
345 #define COMPACT_FLAGS   (WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K |         \
346                          WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K |         \
347                          WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K |        \
348                          WIMLIB_EXTRACT_FLAG_COMPACT_LZX)
349
350
351
352 /*
353  * If not done already, load the patterns from the [PrepopulateList] section of
354  * WimBootCompress.ini in the WIM image being extracted.
355  *
356  * Note: WimBootCompress.ini applies to both types of "external backing":
357  *
358  *      - WIM backing ("WIMBoot" - Windows 8.1 and later)
359  *      - File backing ("System Compression" - Windows 10 and later)
360  */
361 static int
362 load_prepopulate_pats(struct win32_apply_ctx *ctx)
363 {
364         const wchar_t *path = L"\\Windows\\System32\\WimBootCompress.ini";
365         struct wim_dentry *dentry;
366         const struct blob_descriptor *blob;
367         int ret;
368         void *buf;
369         struct string_list *strings;
370         void *mem;
371         struct text_file_section sec;
372
373         if (ctx->tried_to_load_prepopulate_list)
374                 return 0;
375
376         ctx->tried_to_load_prepopulate_list = true;
377
378         dentry = get_dentry(ctx->common.wim, path, WIMLIB_CASE_INSENSITIVE);
379         if (!dentry ||
380             (dentry->d_inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
381                                               FILE_ATTRIBUTE_REPARSE_POINT |
382                                               FILE_ATTRIBUTE_ENCRYPTED)) ||
383             !(blob = inode_get_blob_for_unnamed_data_stream(dentry->d_inode,
384                                                             ctx->common.wim->blob_table)))
385         {
386                 WARNING("%ls does not exist in the WIM image.\n"
387                         "          The default configuration will be used instead; it assumes that all\n"
388                         "          files are valid for external backing regardless of path, equivalent\n"
389                         "          to an empty [PrepopulateList] section.", path);
390                 return WIMLIB_ERR_PATH_DOES_NOT_EXIST;
391         }
392
393         ret = read_blob_into_alloc_buf(blob, &buf);
394         if (ret)
395                 return ret;
396
397         strings = CALLOC(1, sizeof(struct string_list));
398         if (!strings) {
399                 FREE(buf);
400                 return WIMLIB_ERR_NOMEM;
401         }
402
403         sec.name = T("PrepopulateList");
404         sec.strings = strings;
405
406         ret = do_load_text_file(path, buf, blob->size, &mem, &sec, 1,
407                                 LOAD_TEXT_FILE_REMOVE_QUOTES |
408                                         LOAD_TEXT_FILE_NO_WARNINGS,
409                                 mangle_pat);
410         STATIC_ASSERT(OS_PREFERRED_PATH_SEPARATOR == WIM_PATH_SEPARATOR);
411         FREE(buf);
412         if (ret) {
413                 FREE(strings);
414                 return ret;
415         }
416         ctx->prepopulate_pats = strings;
417         ctx->mem_prepopulate_pats = mem;
418         return 0;
419 }
420
421 /* Returns %true if the specified absolute path to a file in the WIM image can
422  * be subject to external backing when extracted.  Otherwise returns %false.  */
423 static bool
424 can_externally_back_path(const wchar_t *path, const struct win32_apply_ctx *ctx)
425 {
426         /* Does the path match a pattern given in the [PrepopulateList] section
427          * of WimBootCompress.ini?  */
428         if (ctx->prepopulate_pats && match_pattern_list(path, ctx->prepopulate_pats))
429                 return false;
430
431         /* Since we attempt to modify the SYSTEM registry after it's extracted
432          * (see end_wimboot_extraction()), it can't be extracted as externally
433          * backed.  This extends to associated files such as SYSTEM.LOG that
434          * also must be writable in order to write to the registry.  Normally,
435          * SYSTEM is in [PrepopulateList], and the SYSTEM.* files match patterns
436          * in [ExclusionList] and therefore are not captured in the WIM at all.
437          * However, a WIM that wasn't specifically captured in "WIMBoot mode"
438          * may contain SYSTEM.* files.  So to make things "just work", hard-code
439          * the pattern.  */
440         if (match_path(path, L"\\Windows\\System32\\config\\SYSTEM*", false))
441                 return false;
442
443         return true;
444 }
445
446 /* Can the specified WIM resource be used as the source of an external backing
447  * for the wof.sys WIM provider?  */
448 static bool
449 is_resource_valid_for_external_backing(const struct wim_resource_descriptor *rdesc,
450                                        struct win32_apply_ctx *ctx)
451 {
452         /* Must be the original WIM file format.  This check excludes pipable
453          * resources and solid resources.  It also excludes other resources
454          * contained in such files even if they would be otherwise compatible.
455          */
456         if (rdesc->wim->hdr.magic != WIM_MAGIC ||
457             rdesc->wim->hdr.wim_version != WIM_VERSION_DEFAULT)
458         {
459                 ctx->wimboot.have_wrong_version_wims = true;
460                 return false;
461         }
462
463         /*
464          * Whitelist of compression types and chunk sizes supported by
465          * Microsoft's WOF driver.
466          *
467          * Notes:
468          *    - Uncompressed WIMs result in BSOD.  However, this only applies to
469          *      the WIM file itself, not to uncompressed resources in a WIM file
470          *      that is otherwise compressed.
471          *    - XPRESS 64K sometimes appears to work, but sometimes it causes
472          *      reads to fail with STATUS_UNSUCCESSFUL.
473          */
474         switch (rdesc->compression_type) {
475         case WIMLIB_COMPRESSION_TYPE_NONE:
476                 if (rdesc->wim->compression_type == WIMLIB_COMPRESSION_TYPE_NONE) {
477                         ctx->wimboot.have_uncompressed_wims = true;
478                         return false;
479                 }
480                 break;
481         case WIMLIB_COMPRESSION_TYPE_XPRESS:
482                 switch (rdesc->chunk_size) {
483                 case 4096:
484                 case 8192:
485                 case 16384:
486                 case 32768:
487                         break;
488                 default:
489                         ctx->wimboot.have_unsupported_compressed_resources = true;
490                         return false;
491                 }
492                 break;
493         case WIMLIB_COMPRESSION_TYPE_LZX:
494                 switch (rdesc->chunk_size) {
495                 case 32768:
496                         break;
497                 default:
498                         ctx->wimboot.have_unsupported_compressed_resources = true;
499                         return false;
500                 }
501                 break;
502         default:
503                 ctx->wimboot.have_unsupported_compressed_resources = true;
504                 return false;
505         }
506
507         /* Microsoft's WoF driver errors out if it tries to satisfy a read with
508          * ending offset >= 4 GiB from an externally backed file.  */
509         if (rdesc->uncompressed_size > 4200000000) {
510                 ctx->wimboot.have_huge_resources = true;
511                 return false;
512         }
513
514         return true;
515 }
516
517 #define EXTERNAL_BACKING_NOT_ENABLED            -1
518 #define EXTERNAL_BACKING_NOT_POSSIBLE           -2
519 #define EXTERNAL_BACKING_EXCLUDED               -3
520
521 /*
522  * Determines whether the specified file will be externally backed.  Returns a
523  * negative status code if no, 0 if yes, or a positive wimlib error code on
524  * error.  If the file is excluded from external backing based on its path, then
525  * *excluded_dentry_ret is set to the dentry for the path that matched the
526  * exclusion rule.
527  *
528  * Note that this logic applies to both types of "external backing":
529  *
530  *      - WIM backing ("WIMBoot" - Windows 8.1 and later)
531  *      - File backing ("System Compression" - Windows 10 and later)
532  *
533  * However, in the case of WIM backing we also need to validate that the WIM
534  * resource that would be the source of the backing is supported by the wof.sys
535  * WIM provider.
536  */
537 static int
538 will_externally_back_inode(struct wim_inode *inode, struct win32_apply_ctx *ctx,
539                            const struct wim_dentry **excluded_dentry_ret,
540                            bool wimboot_mode)
541 {
542         struct wim_dentry *dentry;
543         struct blob_descriptor *blob;
544         int ret;
545
546         if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
547                 return WIMLIB_ERR_NOMEM;
548
549         if (inode->i_can_externally_back)
550                 return 0;
551
552         /* This may do redundant checks because the cached value
553          * i_can_externally_back is 2-state (as opposed to 3-state:
554          * unknown/no/yes).  But most files can be externally backed, so this
555          * way is fine.  */
556
557         if (inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
558                                    FILE_ATTRIBUTE_REPARSE_POINT |
559                                    FILE_ATTRIBUTE_ENCRYPTED))
560                 return EXTERNAL_BACKING_NOT_POSSIBLE;
561
562         blob = inode_get_blob_for_unnamed_data_stream_resolved(inode);
563
564         if (!blob)
565                 return EXTERNAL_BACKING_NOT_POSSIBLE;
566
567         if (wimboot_mode &&
568             (blob->blob_location != BLOB_IN_WIM ||
569              !is_resource_valid_for_external_backing(blob->rdesc, ctx)))
570                 return EXTERNAL_BACKING_NOT_POSSIBLE;
571
572         /*
573          * We need to check the patterns in [PrepopulateList] against every name
574          * of the inode, in case any of them match.
575          */
576
577         inode_for_each_extraction_alias(dentry, inode) {
578
579                 ret = calculate_dentry_full_path(dentry);
580                 if (ret)
581                         return ret;
582
583                 if (!can_externally_back_path(dentry->d_full_path, ctx)) {
584                         if (excluded_dentry_ret)
585                                 *excluded_dentry_ret = dentry;
586                         return EXTERNAL_BACKING_EXCLUDED;
587                 }
588         }
589
590         inode->i_can_externally_back = 1;
591         return 0;
592 }
593
594 /*
595  * Determines if the unnamed data stream of a file will be created as a WIM
596  * external backing (a "WIMBoot pointer file"), as opposed to a standard
597  * extraction.
598  */
599 static int
600 win32_will_back_from_wim(struct wim_dentry *dentry, struct apply_ctx *_ctx)
601 {
602         struct win32_apply_ctx *ctx = (struct win32_apply_ctx *)_ctx;
603
604         if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT))
605                 return EXTERNAL_BACKING_NOT_ENABLED;
606
607         return will_externally_back_inode(dentry->d_inode, ctx, NULL, true);
608 }
609
610 /* Find the WOF registration information for the specified WIM file.  */
611 static struct wimboot_wim *
612 find_wimboot_wim(WIMStruct *wim_to_find, struct win32_apply_ctx *ctx)
613 {
614         for (size_t i = 0; i < ctx->wimboot.num_wims; i++)
615                 if (wim_to_find == ctx->wimboot.wims[i].wim)
616                         return &ctx->wimboot.wims[i];
617
618         wimlib_assert(0);
619         return NULL;
620 }
621
622 static int
623 set_backed_from_wim(HANDLE h, struct wim_inode *inode, struct win32_apply_ctx *ctx)
624 {
625         int ret;
626         const struct wim_dentry *excluded_dentry;
627         const struct blob_descriptor *blob;
628         const struct wimboot_wim *wimboot_wim;
629
630         ret = will_externally_back_inode(inode, ctx, &excluded_dentry, true);
631         if (ret > 0) /* Error.  */
632                 return ret;
633
634         if (ret < 0 && ret != EXTERNAL_BACKING_EXCLUDED)
635                 return 0; /* Not externally backing, other than due to exclusion.  */
636
637         if (unlikely(ret == EXTERNAL_BACKING_EXCLUDED)) {
638                 /* Not externally backing due to exclusion.  */
639                 union wimlib_progress_info info;
640
641                 build_extraction_path(excluded_dentry, ctx);
642
643                 info.wimboot_exclude.path_in_wim = excluded_dentry->d_full_path;
644                 info.wimboot_exclude.extraction_path = current_path(ctx);
645
646                 return call_progress(ctx->common.progfunc,
647                                      WIMLIB_PROGRESS_MSG_WIMBOOT_EXCLUDE,
648                                      &info, ctx->common.progctx);
649         }
650
651         /* Externally backing.  */
652
653         blob = inode_get_blob_for_unnamed_data_stream_resolved(inode);
654         wimboot_wim = find_wimboot_wim(blob->rdesc->wim, ctx);
655
656         if (unlikely(!wimboot_set_pointer(h,
657                                           blob,
658                                           wimboot_wim->data_source_id,
659                                           wimboot_wim->blob_table_hash,
660                                           ctx->wimboot.wof_running)))
661         {
662                 const DWORD err = GetLastError();
663
664                 build_extraction_path(inode_first_extraction_dentry(inode), ctx);
665                 win32_error(err, L"\"%ls\": Couldn't set WIMBoot pointer data",
666                             current_path(ctx));
667                 return WIMLIB_ERR_WIMBOOT;
668         }
669         return 0;
670 }
671
672 /* Calculates the SHA-1 message digest of the WIM's blob table.  */
673 static int
674 hash_blob_table(WIMStruct *wim, u8 hash[SHA1_HASH_SIZE])
675 {
676         return wim_reshdr_to_hash(&wim->hdr.blob_table_reshdr, wim, hash);
677 }
678
679 static int
680 register_wim_with_wof(WIMStruct *wim, struct win32_apply_ctx *ctx)
681 {
682         struct wimboot_wim *p;
683         int ret;
684
685         /* Check if already registered  */
686         for (size_t i = 0; i < ctx->wimboot.num_wims; i++)
687                 if (wim == ctx->wimboot.wims[i].wim)
688                         return 0;
689
690         /* Not yet registered  */
691
692         p = REALLOC(ctx->wimboot.wims,
693                     (ctx->wimboot.num_wims + 1) * sizeof(ctx->wimboot.wims[0]));
694         if (!p)
695                 return WIMLIB_ERR_NOMEM;
696         ctx->wimboot.wims = p;
697
698         ctx->wimboot.wims[ctx->wimboot.num_wims].wim = wim;
699
700         ret = hash_blob_table(wim, ctx->wimboot.wims[ctx->wimboot.num_wims].blob_table_hash);
701         if (ret)
702                 return ret;
703
704         ret = wimboot_alloc_data_source_id(wim->filename,
705                                            wim->hdr.guid,
706                                            ctx->common.wim->current_image,
707                                            ctx->common.target,
708                                            &ctx->wimboot.wims[ctx->wimboot.num_wims].data_source_id,
709                                            &ctx->wimboot.wof_running);
710         if (ret)
711                 return ret;
712
713         ctx->wimboot.num_wims++;
714         return 0;
715 }
716
717 /* Prepare for doing a "WIMBoot" extraction by registering each source WIM file
718  * with WOF on the target volume.  */
719 static int
720 start_wimboot_extraction(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
721 {
722         int ret;
723         struct wim_dentry *dentry;
724
725         if (!xml_get_wimboot(ctx->common.wim->xml_info,
726                              ctx->common.wim->current_image))
727                 WARNING("The WIM image is not marked as WIMBoot compatible.  This usually\n"
728                         "          means it is not intended to be used to back a Windows operating\n"
729                         "          system.  Proceeding anyway.");
730
731         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
732                 struct blob_descriptor *blob;
733
734                 ret = win32_will_back_from_wim(dentry, &ctx->common);
735                 if (ret > 0) /* Error */
736                         return ret;
737                 if (ret < 0) /* Won't externally back */
738                         continue;
739
740                 blob = inode_get_blob_for_unnamed_data_stream_resolved(dentry->d_inode);
741                 ret = register_wim_with_wof(blob->rdesc->wim, ctx);
742                 if (ret)
743                         return ret;
744         }
745
746         if (ctx->wimboot.have_wrong_version_wims) {
747   WARNING("At least one of the source WIM files uses a version of the WIM\n"
748 "          file format that not supported by Microsoft's wof.sys driver.\n"
749 "          Files whose data is contained in one of these WIM files will be\n"
750 "          extracted as full files rather than externally backed.");
751         }
752
753         if (ctx->wimboot.have_uncompressed_wims) {
754   WARNING("At least one of the source WIM files is uncompressed.  Files whose\n"
755 "          data is contained in an uncompressed WIM file will be extracted as\n"
756 "          full files rather than externally backed, since uncompressed WIM\n"
757 "          files are not supported by Microsoft's wof.sys driver.");
758         }
759
760         if (ctx->wimboot.have_unsupported_compressed_resources) {
761   WARNING("At least one of the source WIM files uses a compression format that\n"
762 "          is not supported by Microsoft's wof.sys driver.  Files whose data is\n"
763 "          contained in a compressed resource in one of these WIM files will be\n"
764 "          extracted as full files rather than externally backed.  (The\n"
765 "          compression formats supported by wof.sys are: XPRESS 4K, XPRESS 8K,\n"
766 "          XPRESS 16K, XPRESS 32K, and LZX 32K.)");
767         }
768
769         if (ctx->wimboot.have_huge_resources) {
770   WARNING("Some files exceeded 4.2 GB in size.  Such files will be extracted\n"
771 "          as full files rather than externally backed, since very large files\n"
772 "          are not supported by Microsoft's wof.sys driver.");
773         }
774
775         return 0;
776 }
777
778 static void
779 build_win32_extraction_path(const struct wim_dentry *dentry,
780                             struct win32_apply_ctx *ctx);
781
782 /* Sets WimBoot=1 in the extracted SYSTEM registry hive.
783  *
784  * WIMGAPI does this, and it's possible that it's important.
785  * But I don't know exactly what this value means to Windows.  */
786 static int
787 end_wimboot_extraction(struct win32_apply_ctx *ctx)
788 {
789         struct wim_dentry *dentry;
790         wchar_t subkeyname[32];
791         LONG res;
792         LONG res2;
793         HKEY key;
794         DWORD value;
795
796         dentry = get_dentry(ctx->common.wim, L"\\Windows\\System32\\config\\SYSTEM",
797                             WIMLIB_CASE_INSENSITIVE);
798
799         if (!dentry || !will_extract_dentry(dentry))
800                 goto out;
801
802         if (!will_extract_dentry(wim_get_current_root_dentry(ctx->common.wim)))
803                 goto out;
804
805         /* Not bothering to use the native routines (e.g. NtLoadKey()) for this.
806          * If this doesn't work, you probably also have many other problems.  */
807
808         build_win32_extraction_path(dentry, ctx);
809
810         randomize_char_array_with_alnum(subkeyname, 20);
811         subkeyname[20] = L'\0';
812
813         res = RegLoadKey(HKEY_LOCAL_MACHINE, subkeyname, ctx->pathbuf.Buffer);
814         if (res)
815                 goto out_check_res;
816
817         wcscpy(&subkeyname[20], L"\\Setup");
818
819         res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, subkeyname, 0, NULL,
820                              REG_OPTION_BACKUP_RESTORE, 0, NULL, &key, NULL);
821         if (res)
822                 goto out_unload_key;
823
824         value = 1;
825
826         res = RegSetValueEx(key, L"WimBoot", 0, REG_DWORD,
827                             (const BYTE *)&value, sizeof(DWORD));
828         if (res)
829                 goto out_close_key;
830
831         res = RegFlushKey(key);
832
833 out_close_key:
834         res2 = RegCloseKey(key);
835         if (!res)
836                 res = res2;
837 out_unload_key:
838         subkeyname[20] = L'\0';
839         RegUnLoadKey(HKEY_LOCAL_MACHINE, subkeyname);
840 out_check_res:
841         if (res) {
842                 /* Warning only.  */
843                 win32_warning(res, L"Failed to set \\Setup: dword \"WimBoot\"=1 "
844                               "value in registry hive \"%ls\"",
845                               ctx->pathbuf.Buffer);
846         }
847 out:
848         return 0;
849 }
850
851 /* Returns the number of wide characters needed to represent the path to the
852  * specified @dentry, relative to the target directory, when extracted.
853  *
854  * Does not include null terminator (not needed for NtCreateFile).  */
855 static size_t
856 dentry_extraction_path_length(const struct wim_dentry *dentry)
857 {
858         size_t len = 0;
859         const struct wim_dentry *d;
860
861         d = dentry;
862         do {
863                 len += d->d_extraction_name_nchars + 1;
864                 d = d->d_parent;
865         } while (!dentry_is_root(d) && will_extract_dentry(d));
866
867         return --len;  /* No leading slash  */
868 }
869
870 /* Returns the length of the longest string that might need to be appended to
871  * the path to an alias of an inode to open or create a named data stream.
872  *
873  * If the inode has no named data streams, this will be 0.  Otherwise, this will
874  * be 1 plus the length of the longest-named data stream, since the data stream
875  * name must be separated from the path by the ':' character.  */
876 static size_t
877 inode_longest_named_data_stream_spec(const struct wim_inode *inode)
878 {
879         size_t max = 0;
880         for (unsigned i = 0; i < inode->i_num_streams; i++) {
881                 const struct wim_inode_stream *strm = &inode->i_streams[i];
882                 if (!stream_is_named_data_stream(strm))
883                         continue;
884                 size_t len = utf16le_len_chars(strm->stream_name);
885                 if (len > max)
886                         max = len;
887         }
888         if (max)
889                 max += 1;
890         return max;
891 }
892
893 /* Find the length, in wide characters, of the longest path needed for
894  * extraction of any file in @dentry_list relative to the target directory.
895  *
896  * Accounts for named data streams, but does not include null terminator (not
897  * needed for NtCreateFile).  */
898 static size_t
899 compute_path_max(struct list_head *dentry_list)
900 {
901         size_t max = 0;
902         const struct wim_dentry *dentry;
903
904         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
905                 size_t len;
906
907                 len = dentry_extraction_path_length(dentry);
908
909                 /* Account for named data streams  */
910                 len += inode_longest_named_data_stream_spec(dentry->d_inode);
911
912                 if (len > max)
913                         max = len;
914         }
915
916         return max;
917 }
918
919 /* Build the path at which to extract the @dentry, relative to the target
920  * directory.
921  *
922  * The path is saved in ctx->pathbuf.  */
923 static void
924 build_extraction_path(const struct wim_dentry *dentry,
925                       struct win32_apply_ctx *ctx)
926 {
927         size_t len;
928         wchar_t *p;
929         const struct wim_dentry *d;
930
931         len = dentry_extraction_path_length(dentry);
932
933         ctx->pathbuf.Length = len * sizeof(wchar_t);
934         p = ctx->pathbuf.Buffer + len;
935         for (d = dentry;
936              !dentry_is_root(d->d_parent) && will_extract_dentry(d->d_parent);
937              d = d->d_parent)
938         {
939                 p -= d->d_extraction_name_nchars;
940                 if (d->d_extraction_name_nchars)
941                         wmemcpy(p, d->d_extraction_name,
942                                 d->d_extraction_name_nchars);
943                 *--p = '\\';
944         }
945         /* No leading slash  */
946         p -= d->d_extraction_name_nchars;
947         wmemcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
948 }
949
950 /* Build the path at which to extract the @dentry, relative to the target
951  * directory, adding the suffix for a named data stream.
952  *
953  * The path is saved in ctx->pathbuf.  */
954 static void
955 build_extraction_path_with_ads(const struct wim_dentry *dentry,
956                                struct win32_apply_ctx *ctx,
957                                const wchar_t *stream_name,
958                                size_t stream_name_nchars)
959 {
960         wchar_t *p;
961
962         build_extraction_path(dentry, ctx);
963
964         /* Add :NAME for named data stream  */
965         p = ctx->pathbuf.Buffer + (ctx->pathbuf.Length / sizeof(wchar_t));
966         *p++ = L':';
967         wmemcpy(p, stream_name, stream_name_nchars);
968         ctx->pathbuf.Length += (1 + stream_name_nchars) * sizeof(wchar_t);
969 }
970
971 /* Build the Win32 namespace path to the specified @dentry when extracted.
972  *
973  * The path is saved in ctx->pathbuf and will be null terminated.
974  *
975  * XXX: We could get rid of this if it wasn't needed for the file encryption
976  * APIs, and the registry manipulation in WIMBoot mode.  */
977 static void
978 build_win32_extraction_path(const struct wim_dentry *dentry,
979                             struct win32_apply_ctx *ctx)
980 {
981         build_extraction_path(dentry, ctx);
982
983         /* Prepend target_ntpath to our relative path, then change \??\ into \\?\  */
984
985         memmove(ctx->pathbuf.Buffer +
986                         (ctx->target_ntpath.Length / sizeof(wchar_t)) + 1,
987                 ctx->pathbuf.Buffer, ctx->pathbuf.Length);
988         memcpy(ctx->pathbuf.Buffer, ctx->target_ntpath.Buffer,
989                 ctx->target_ntpath.Length);
990         ctx->pathbuf.Buffer[ctx->target_ntpath.Length / sizeof(wchar_t)] = L'\\';
991         ctx->pathbuf.Length += ctx->target_ntpath.Length + sizeof(wchar_t);
992         ctx->pathbuf.Buffer[ctx->pathbuf.Length / sizeof(wchar_t)] = L'\0';
993
994         wimlib_assert(ctx->pathbuf.Length >= 4 * sizeof(wchar_t) &&
995                       !wmemcmp(ctx->pathbuf.Buffer, L"\\??\\", 4));
996
997         ctx->pathbuf.Buffer[1] = L'\\';
998
999 }
1000
1001 /* Returns a "printable" representation of the last relative NT path that was
1002  * constructed with build_extraction_path() or build_extraction_path_with_ads().
1003  *
1004  * This will be overwritten by the next call to this function.  */
1005 static const wchar_t *
1006 current_path(struct win32_apply_ctx *ctx)
1007 {
1008         wchar_t *p = ctx->print_buffer;
1009
1010         p = wmempcpy(p, ctx->common.target, ctx->common.target_nchars);
1011         *p++ = L'\\';
1012         p = wmempcpy(p, ctx->pathbuf.Buffer, ctx->pathbuf.Length / sizeof(wchar_t));
1013         *p = L'\0';
1014         return ctx->print_buffer;
1015 }
1016
1017 /* Open handle to the target directory if it is not already open.  If the target
1018  * directory does not exist, this creates it.  */
1019 static int
1020 open_target_directory(struct win32_apply_ctx *ctx)
1021 {
1022         NTSTATUS status;
1023
1024         if (ctx->h_target)
1025                 return 0;
1026
1027         ctx->attr.Length = sizeof(ctx->attr);
1028         ctx->attr.RootDirectory = NULL;
1029         ctx->attr.ObjectName = &ctx->target_ntpath;
1030
1031         /* Don't use FILE_OPEN_REPARSE_POINT here; we want the extraction to
1032          * happen at the directory "pointed to" by the reparse point. */
1033         status = NtCreateFile(&ctx->h_target,
1034                               FILE_TRAVERSE,
1035                               &ctx->attr,
1036                               &ctx->iosb,
1037                               NULL,
1038                               0,
1039                               FILE_SHARE_VALID_FLAGS,
1040                               FILE_OPEN_IF,
1041                               FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT,
1042                               NULL,
1043                               0);
1044         if (!NT_SUCCESS(status)) {
1045                 winnt_error(status, L"Can't open or create directory \"%ls\"",
1046                             ctx->common.target);
1047                 return WIMLIB_ERR_OPENDIR;
1048         }
1049         ctx->attr.RootDirectory = ctx->h_target;
1050         ctx->attr.ObjectName = &ctx->pathbuf;
1051         return 0;
1052 }
1053
1054 static void
1055 close_target_directory(struct win32_apply_ctx *ctx)
1056 {
1057         if (ctx->h_target) {
1058                 NtClose(ctx->h_target);
1059                 ctx->h_target = NULL;
1060                 ctx->attr.RootDirectory = NULL;
1061         }
1062 }
1063
1064 /*
1065  * Ensures the target directory exists and opens a handle to it, in preparation
1066  * of using paths relative to it.
1067  */
1068 static int
1069 prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
1070 {
1071         int ret;
1072         size_t path_max;
1073
1074         ret = win32_path_to_nt_path(ctx->common.target, &ctx->target_ntpath);
1075         if (ret)
1076                 return ret;
1077
1078         ret = open_target_directory(ctx);
1079         if (ret)
1080                 return ret;
1081
1082         path_max = compute_path_max(dentry_list);
1083         /* Add some extra for building Win32 paths for the file encryption APIs,
1084          * and ensure we have at least enough to potentially use a 8.3 name for
1085          * the last component.  */
1086         path_max += max(2 + (ctx->target_ntpath.Length / sizeof(wchar_t)),
1087                         8 + 1 + 3);
1088
1089         ctx->pathbuf.MaximumLength = path_max * sizeof(wchar_t);
1090         ctx->pathbuf.Buffer = MALLOC(ctx->pathbuf.MaximumLength);
1091         if (!ctx->pathbuf.Buffer)
1092                 return WIMLIB_ERR_NOMEM;
1093
1094         ctx->print_buffer = MALLOC((ctx->common.target_nchars + 1 + path_max + 1) *
1095                                    sizeof(wchar_t));
1096         if (!ctx->print_buffer)
1097                 return WIMLIB_ERR_NOMEM;
1098
1099         return 0;
1100 }
1101
1102 /* When creating an inode that will have a short (DOS) name, we create it using
1103  * the long name associated with the short name.  This ensures that the short
1104  * name gets associated with the correct long name.  */
1105 static struct wim_dentry *
1106 first_extraction_alias(const struct wim_inode *inode)
1107 {
1108         struct wim_dentry *dentry;
1109
1110         inode_for_each_extraction_alias(dentry, inode)
1111                 if (dentry_has_short_name(dentry))
1112                         return dentry;
1113         return inode_first_extraction_dentry(inode);
1114 }
1115
1116 /*
1117  * Set or clear FILE_ATTRIBUTE_COMPRESSED if the inherited value is different
1118  * from the desired value.
1119  *
1120  * Note that you can NOT override the inherited value of
1121  * FILE_ATTRIBUTE_COMPRESSED directly with NtCreateFile().
1122  */
1123 static int
1124 adjust_compression_attribute(HANDLE h, const struct wim_dentry *dentry,
1125                              struct win32_apply_ctx *ctx)
1126 {
1127         const bool compressed = (dentry->d_inode->i_attributes &
1128                                  FILE_ATTRIBUTE_COMPRESSED);
1129         FILE_BASIC_INFORMATION info;
1130         USHORT compression_state;
1131         NTSTATUS status;
1132
1133         if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)
1134                 return 0;
1135
1136         if (!ctx->common.supported_features.compressed_files)
1137                 return 0;
1138
1139
1140         /* Get current attributes  */
1141         status = NtQueryInformationFile(h, &ctx->iosb, &info, sizeof(info),
1142                                         FileBasicInformation);
1143         if (NT_SUCCESS(status) &&
1144             compressed == !!(info.FileAttributes & FILE_ATTRIBUTE_COMPRESSED))
1145         {
1146                 /* Nothing needs to be done.  */
1147                 return 0;
1148         }
1149
1150         /* Set the new compression state  */
1151
1152         if (compressed)
1153                 compression_state = COMPRESSION_FORMAT_DEFAULT;
1154         else
1155                 compression_state = COMPRESSION_FORMAT_NONE;
1156
1157         status = winnt_fsctl(h, FSCTL_SET_COMPRESSION,
1158                              &compression_state, sizeof(USHORT), NULL, 0, NULL);
1159         if (NT_SUCCESS(status))
1160                 return 0;
1161
1162         winnt_error(status, L"Can't %s compression attribute on \"%ls\"",
1163                     (compressed ? "set" : "clear"), current_path(ctx));
1164         return WIMLIB_ERR_SET_ATTRIBUTES;
1165 }
1166
1167 static bool
1168 need_sparse_flag(const struct wim_inode *inode,
1169                  const struct win32_apply_ctx *ctx)
1170 {
1171         return (inode->i_attributes & FILE_ATTRIBUTE_SPARSE_FILE) &&
1172                 ctx->common.supported_features.sparse_files;
1173 }
1174
1175 static int
1176 set_sparse_flag(HANDLE h, struct win32_apply_ctx *ctx)
1177 {
1178         NTSTATUS status;
1179
1180         status = winnt_fsctl(h, FSCTL_SET_SPARSE, NULL, 0, NULL, 0, NULL);
1181         if (NT_SUCCESS(status))
1182                 return 0;
1183
1184         winnt_error(status, L"Can't set sparse flag on \"%ls\"",
1185                     current_path(ctx));
1186         return WIMLIB_ERR_SET_ATTRIBUTES;
1187 }
1188
1189 /* Try to enable short name support on the target volume.  If successful, return
1190  * true.  If unsuccessful, issue a warning and return false.  */
1191 static bool
1192 try_to_enable_short_names(const wchar_t *volume)
1193 {
1194         HANDLE h;
1195         FILE_FS_PERSISTENT_VOLUME_INFORMATION info;
1196         BOOL bret;
1197         DWORD bytesReturned;
1198
1199         h = CreateFile(volume, GENERIC_WRITE,
1200                        FILE_SHARE_VALID_FLAGS, NULL, OPEN_EXISTING,
1201                        FILE_FLAG_BACKUP_SEMANTICS, NULL);
1202         if (h == INVALID_HANDLE_VALUE)
1203                 goto fail;
1204
1205         info.VolumeFlags = 0;
1206         info.FlagMask = PERSISTENT_VOLUME_STATE_SHORT_NAME_CREATION_DISABLED;
1207         info.Version = 1;
1208         info.Reserved = 0;
1209
1210         bret = DeviceIoControl(h, FSCTL_SET_PERSISTENT_VOLUME_STATE,
1211                                &info, sizeof(info), NULL, 0,
1212                                &bytesReturned, NULL);
1213
1214         CloseHandle(h);
1215
1216         if (!bret)
1217                 goto fail;
1218         return true;
1219
1220 fail:
1221         win32_warning(GetLastError(),
1222                       L"Failed to enable short name support on %ls",
1223                       volume + 4);
1224         return false;
1225 }
1226
1227 static NTSTATUS
1228 remove_conflicting_short_name(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx)
1229 {
1230         wchar_t *name;
1231         wchar_t *end;
1232         NTSTATUS status;
1233         HANDLE h;
1234         size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) +
1235                          (13 * sizeof(wchar_t));
1236         u8 buf[bufsize] _aligned_attribute(8);
1237         bool retried = false;
1238         FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf;
1239
1240         memset(buf, 0, bufsize);
1241
1242         /* Build the path with the short name.  */
1243         name = &ctx->pathbuf.Buffer[ctx->pathbuf.Length / sizeof(wchar_t)];
1244         while (name != ctx->pathbuf.Buffer && *(name - 1) != L'\\')
1245                 name--;
1246         end = mempcpy(name, dentry->d_short_name, dentry->d_short_name_nbytes);
1247         ctx->pathbuf.Length = ((u8 *)end - (u8 *)ctx->pathbuf.Buffer);
1248
1249         /* Open the conflicting file (by short name).  */
1250         status = NtOpenFile(&h, GENERIC_WRITE | DELETE,
1251                             &ctx->attr, &ctx->iosb,
1252                             FILE_SHARE_VALID_FLAGS,
1253                             FILE_OPEN_REPARSE_POINT | FILE_OPEN_FOR_BACKUP_INTENT);
1254         if (!NT_SUCCESS(status)) {
1255                 winnt_warning(status, L"Can't open \"%ls\"", current_path(ctx));
1256                 goto out;
1257         }
1258
1259 #if 0
1260         WARNING("Overriding conflicting short name; path=\"%ls\"",
1261                 current_path(ctx));
1262 #endif
1263
1264         /* Try to remove the short name on the conflicting file.  */
1265
1266 retry:
1267         status = NtSetInformationFile(h, &ctx->iosb, info, bufsize,
1268                                       FileShortNameInformation);
1269
1270         if (status == STATUS_INVALID_PARAMETER && !retried) {
1271
1272                 /* Microsoft forgot to make it possible to remove short names
1273                  * until Windows 7.  Oops.  Use a random short name instead.  */
1274
1275                 info->FileNameLength = 12 * sizeof(wchar_t);
1276                 for (int i = 0; i < 8; i++)
1277                         info->FileName[i] = 'A' + (rand() % 26);
1278                 info->FileName[8] = L'.';
1279                 info->FileName[9] = L'W';
1280                 info->FileName[10] = L'L';
1281                 info->FileName[11] = L'B';
1282                 info->FileName[12] = L'\0';
1283                 retried = true;
1284                 goto retry;
1285         }
1286         NtClose(h);
1287 out:
1288         build_extraction_path(dentry, ctx);
1289         return status;
1290 }
1291
1292 /* Set the short name on the open file @h which has been created at the location
1293  * indicated by @dentry.
1294  *
1295  * Note that this may add, change, or remove the short name.
1296  *
1297  * @h must be opened with DELETE access.
1298  *
1299  * Returns 0 or WIMLIB_ERR_SET_SHORT_NAME.  The latter only happens in
1300  * STRICT_SHORT_NAMES mode.
1301  */
1302 static int
1303 set_short_name(HANDLE h, const struct wim_dentry *dentry,
1304                struct win32_apply_ctx *ctx)
1305 {
1306
1307         if (!ctx->common.supported_features.short_names)
1308                 return 0;
1309
1310         /*
1311          * Note: The size of the FILE_NAME_INFORMATION buffer must be such that
1312          * FileName contains at least 2 wide characters (4 bytes).  Otherwise,
1313          * NtSetInformationFile() will return STATUS_INFO_LENGTH_MISMATCH.  This
1314          * is despite the fact that FileNameLength can validly be 0 or 2 bytes,
1315          * with the former case being removing the existing short name if
1316          * present, rather than setting one.
1317          *
1318          * The null terminator is seemingly optional, but to be safe we include
1319          * space for it and zero all unused space.
1320          */
1321
1322         size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) +
1323                          max(dentry->d_short_name_nbytes, sizeof(wchar_t)) +
1324                          sizeof(wchar_t);
1325         u8 buf[bufsize] _aligned_attribute(8);
1326         FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf;
1327         NTSTATUS status;
1328         bool tried_to_remove_existing = false;
1329
1330         memset(buf, 0, bufsize);
1331
1332         info->FileNameLength = dentry->d_short_name_nbytes;
1333         memcpy(info->FileName, dentry->d_short_name, dentry->d_short_name_nbytes);
1334
1335 retry:
1336         status = NtSetInformationFile(h, &ctx->iosb, info, bufsize,
1337                                       FileShortNameInformation);
1338         if (NT_SUCCESS(status))
1339                 return 0;
1340
1341         if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) {
1342                 if (dentry->d_short_name_nbytes == 0)
1343                         return 0;
1344                 if (!ctx->tried_to_enable_short_names) {
1345                         wchar_t volume[7];
1346                         int ret;
1347
1348                         ctx->tried_to_enable_short_names = true;
1349
1350                         ret = win32_get_drive_path(ctx->common.target,
1351                                                    volume);
1352                         if (ret)
1353                                 return ret;
1354                         if (try_to_enable_short_names(volume))
1355                                 goto retry;
1356                 }
1357         }
1358
1359         /*
1360          * Short names can conflict in several cases:
1361          *
1362          * - a file being extracted has a short name conflicting with an
1363          *   existing file
1364          *
1365          * - a file being extracted has a short name conflicting with another
1366          *   file being extracted (possible, but shouldn't happen)
1367          *
1368          * - a file being extracted has a short name that conflicts with the
1369          *   automatically generated short name of a file we previously
1370          *   extracted, but failed to set the short name for.  Sounds unlikely,
1371          *   but this actually does happen fairly often on versions of Windows
1372          *   prior to Windows 7 because they do not support removing short names
1373          *   from files.
1374          */
1375         if (unlikely(status == STATUS_OBJECT_NAME_COLLISION) &&
1376             dentry->d_short_name_nbytes && !tried_to_remove_existing)
1377         {
1378                 tried_to_remove_existing = true;
1379                 status = remove_conflicting_short_name(dentry, ctx);
1380                 if (NT_SUCCESS(status))
1381                         goto retry;
1382         }
1383
1384         /* By default, failure to set short names is not an error (since short
1385          * names aren't too important anymore...).  */
1386         if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES)) {
1387                 if (dentry->d_short_name_nbytes)
1388                         ctx->num_set_short_name_failures++;
1389                 else
1390                         ctx->num_remove_short_name_failures++;
1391                 return 0;
1392         }
1393
1394         winnt_error(status, L"Can't set short name on \"%ls\"", current_path(ctx));
1395         return WIMLIB_ERR_SET_SHORT_NAME;
1396 }
1397
1398 /*
1399  * A wrapper around NtCreateFile() to make it slightly more usable...
1400  * This uses the path currently constructed in ctx->pathbuf.
1401  *
1402  * Also, we always specify SYNCHRONIZE access, FILE_OPEN_FOR_BACKUP_INTENT, and
1403  * FILE_OPEN_REPARSE_POINT.
1404  */
1405 static NTSTATUS
1406 do_create_file(PHANDLE FileHandle,
1407                ACCESS_MASK DesiredAccess,
1408                PLARGE_INTEGER AllocationSize,
1409                ULONG FileAttributes,
1410                ULONG CreateDisposition,
1411                ULONG CreateOptions,
1412                struct win32_apply_ctx *ctx)
1413 {
1414         return NtCreateFile(FileHandle,
1415                             DesiredAccess | SYNCHRONIZE,
1416                             &ctx->attr,
1417                             &ctx->iosb,
1418                             AllocationSize,
1419                             FileAttributes,
1420                             FILE_SHARE_VALID_FLAGS,
1421                             CreateDisposition,
1422                             CreateOptions |
1423                                 FILE_OPEN_FOR_BACKUP_INTENT |
1424                                 FILE_OPEN_REPARSE_POINT,
1425                             NULL,
1426                             0);
1427 }
1428
1429 /* Like do_create_file(), but builds the extraction path of the @dentry first.
1430  */
1431 static NTSTATUS
1432 create_file(PHANDLE FileHandle,
1433             ACCESS_MASK DesiredAccess,
1434             PLARGE_INTEGER AllocationSize,
1435             ULONG FileAttributes,
1436             ULONG CreateDisposition,
1437             ULONG CreateOptions,
1438             const struct wim_dentry *dentry,
1439             struct win32_apply_ctx *ctx)
1440 {
1441         build_extraction_path(dentry, ctx);
1442         return do_create_file(FileHandle,
1443                               DesiredAccess,
1444                               AllocationSize,
1445                               FileAttributes,
1446                               CreateDisposition,
1447                               CreateOptions,
1448                               ctx);
1449 }
1450
1451 static int
1452 delete_file_or_stream(struct win32_apply_ctx *ctx)
1453 {
1454         NTSTATUS status;
1455         HANDLE h;
1456         ULONG perms = DELETE;
1457         ULONG flags = FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE;
1458
1459         /* First try opening the file with FILE_DELETE_ON_CLOSE.  In most cases,
1460          * all we have to do is that plus close the file handle.  */
1461 retry:
1462         status = do_create_file(&h, perms, NULL, 0, FILE_OPEN, flags, ctx);
1463
1464         if (unlikely(status == STATUS_CANNOT_DELETE)) {
1465                 /* This error occurs for files with FILE_ATTRIBUTE_READONLY set.
1466                  * Try an alternate approach: first open the file without
1467                  * FILE_DELETE_ON_CLOSE, then reset the file attributes, then
1468                  * set the "delete" disposition on the handle.  */
1469                 if (flags & FILE_DELETE_ON_CLOSE) {
1470                         flags &= ~FILE_DELETE_ON_CLOSE;
1471                         perms |= FILE_WRITE_ATTRIBUTES;
1472                         goto retry;
1473                 }
1474         }
1475
1476         if (unlikely(!NT_SUCCESS(status))) {
1477                 winnt_error(status, L"Can't open \"%ls\" for deletion "
1478                             "(perms=%x, flags=%x)",
1479                             current_path(ctx), perms, flags);
1480                 return WIMLIB_ERR_OPEN;
1481         }
1482
1483         if (unlikely(!(flags & FILE_DELETE_ON_CLOSE))) {
1484
1485                 FILE_BASIC_INFORMATION basic_info =
1486                         { .FileAttributes = FILE_ATTRIBUTE_NORMAL };
1487                 status = NtSetInformationFile(h, &ctx->iosb, &basic_info,
1488                                               sizeof(basic_info),
1489                                               FileBasicInformation);
1490
1491                 if (!NT_SUCCESS(status)) {
1492                         winnt_error(status, L"Can't reset attributes of \"%ls\" "
1493                                     "to prepare for deletion", current_path(ctx));
1494                         NtClose(h);
1495                         return WIMLIB_ERR_SET_ATTRIBUTES;
1496                 }
1497
1498                 FILE_DISPOSITION_INFORMATION disp_info =
1499                         { .DoDeleteFile = TRUE };
1500                 status = NtSetInformationFile(h, &ctx->iosb, &disp_info,
1501                                               sizeof(disp_info),
1502                                               FileDispositionInformation);
1503                 if (!NT_SUCCESS(status)) {
1504                         winnt_error(status, L"Can't set delete-on-close "
1505                                     "disposition on \"%ls\"", current_path(ctx));
1506                         NtClose(h);
1507                         return WIMLIB_ERR_SET_ATTRIBUTES;
1508                 }
1509         }
1510
1511         status = NtClose(h);
1512         if (unlikely(!NT_SUCCESS(status))) {
1513                 winnt_error(status, L"Error closing \"%ls\" after setting "
1514                             "delete-on-close disposition", current_path(ctx));
1515                 return WIMLIB_ERR_OPEN;
1516         }
1517
1518         return 0;
1519 }
1520
1521 /*
1522  * Create a nondirectory file or named data stream at the current path,
1523  * superseding any that already exists at that path.  If successful, return an
1524  * open handle to the file or named data stream with the requested permissions.
1525  */
1526 static int
1527 supersede_file_or_stream(struct win32_apply_ctx *ctx, DWORD perms,
1528                          HANDLE *h_ret)
1529 {
1530         NTSTATUS status;
1531         bool retried = false;
1532
1533         /* FILE_ATTRIBUTE_SYSTEM is needed to ensure that
1534          * FILE_ATTRIBUTE_ENCRYPTED doesn't get set before we want it to be.  */
1535 retry:
1536         status = do_create_file(h_ret,
1537                                 perms,
1538                                 NULL,
1539                                 FILE_ATTRIBUTE_SYSTEM,
1540                                 FILE_CREATE,
1541                                 FILE_NON_DIRECTORY_FILE,
1542                                 ctx);
1543         if (likely(NT_SUCCESS(status)))
1544                 return 0;
1545
1546         /* STATUS_OBJECT_NAME_COLLISION means that the file or stream already
1547          * exists.  Delete the existing file or stream, then try again.
1548          *
1549          * Note: we don't use FILE_OVERWRITE_IF or FILE_SUPERSEDE because of
1550          * problems with certain file attributes, especially
1551          * FILE_ATTRIBUTE_ENCRYPTED.  FILE_SUPERSEDE is also broken in the
1552          * Windows PE ramdisk.  */
1553         if (status == STATUS_OBJECT_NAME_COLLISION && !retried) {
1554                 int ret = delete_file_or_stream(ctx);
1555                 if (ret)
1556                         return ret;
1557                 retried = true;
1558                 goto retry;
1559         }
1560         winnt_error(status, L"Can't create \"%ls\"", current_path(ctx));
1561         return WIMLIB_ERR_OPEN;
1562 }
1563
1564 /* Set the reparse point @rpbuf of length @rpbuflen on the extracted file
1565  * corresponding to the WIM dentry @dentry.  */
1566 static int
1567 do_set_reparse_point(const struct wim_dentry *dentry,
1568                      const struct reparse_buffer_disk *rpbuf, u16 rpbuflen,
1569                      struct win32_apply_ctx *ctx)
1570 {
1571         NTSTATUS status;
1572         HANDLE h;
1573
1574         status = create_file(&h, GENERIC_WRITE, NULL,
1575                              0, FILE_OPEN, 0, dentry, ctx);
1576         if (!NT_SUCCESS(status))
1577                 goto fail;
1578
1579         status = winnt_fsctl(h, FSCTL_SET_REPARSE_POINT,
1580                              rpbuf, rpbuflen, NULL, 0, NULL);
1581         NtClose(h);
1582
1583         if (NT_SUCCESS(status))
1584                 return 0;
1585
1586         /* On Windows, by default only the Administrator can create symbolic
1587          * links for some reason.  By default we just issue a warning if this
1588          * appears to be the problem.  Use WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS
1589          * to get a hard error.  */
1590         if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS)
1591             && (status == STATUS_PRIVILEGE_NOT_HELD ||
1592                 status == STATUS_ACCESS_DENIED)
1593             && (dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
1594                 dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))
1595         {
1596                 WARNING("Can't create symbolic link \"%ls\"!              \n"
1597                         "          (Need Administrator rights, or at least "
1598                         "the\n"
1599                         "          SeCreateSymbolicLink privilege.)",
1600                         current_path(ctx));
1601                 return 0;
1602         }
1603
1604 fail:
1605         winnt_error(status, L"Can't set reparse data on \"%ls\"",
1606                     current_path(ctx));
1607         return WIMLIB_ERR_SET_REPARSE_DATA;
1608 }
1609
1610 /*
1611  * Create empty named data streams and potentially a reparse point for the
1612  * specified file, if any.
1613  *
1614  * Since these won't have blob descriptors, they won't show up in the call to
1615  * extract_blob_list().  Hence the need for the special case.
1616  */
1617 static int
1618 create_empty_streams(const struct wim_dentry *dentry,
1619                      struct win32_apply_ctx *ctx)
1620 {
1621         const struct wim_inode *inode = dentry->d_inode;
1622         int ret;
1623
1624         for (unsigned i = 0; i < inode->i_num_streams; i++) {
1625                 const struct wim_inode_stream *strm = &inode->i_streams[i];
1626
1627                 if (stream_blob_resolved(strm) != NULL)
1628                         continue;
1629
1630                 if (strm->stream_type == STREAM_TYPE_REPARSE_POINT &&
1631                     ctx->common.supported_features.reparse_points)
1632                 {
1633                         u8 buf[REPARSE_DATA_OFFSET] _aligned_attribute(8);
1634                         struct reparse_buffer_disk *rpbuf =
1635                                 (struct reparse_buffer_disk *)buf;
1636                         complete_reparse_point(rpbuf, inode, 0);
1637                         ret = do_set_reparse_point(dentry, rpbuf,
1638                                                    REPARSE_DATA_OFFSET, ctx);
1639                         if (ret)
1640                                 return ret;
1641                 } else if (stream_is_named_data_stream(strm) &&
1642                            ctx->common.supported_features.named_data_streams)
1643                 {
1644                         HANDLE h;
1645
1646                         build_extraction_path_with_ads(dentry, ctx,
1647                                                        strm->stream_name,
1648                                                        utf16le_len_chars(strm->stream_name));
1649                         /*
1650                          * Note: do not request any permissions on the handle.
1651                          * Otherwise, we may encounter a Windows bug where the
1652                          * parent directory DACL denies read access to the new
1653                          * named data stream, even when using backup semantics!
1654                          */
1655                         ret = supersede_file_or_stream(ctx, 0, &h);
1656
1657                         build_extraction_path(dentry, ctx);
1658
1659                         if (ret)
1660                                 return ret;
1661                         NtClose(h);
1662                 }
1663         }
1664
1665         return 0;
1666 }
1667
1668 /*
1669  * Creates the directory named by @dentry, or uses an existing directory at that
1670  * location.  If necessary, sets the short name and/or fixes compression and
1671  * encryption attributes.
1672  *
1673  * Returns 0, WIMLIB_ERR_MKDIR, or WIMLIB_ERR_SET_SHORT_NAME.
1674  */
1675 static int
1676 create_directory(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx)
1677 {
1678         DWORD perms;
1679         NTSTATUS status;
1680         HANDLE h;
1681         int ret;
1682
1683         /* DELETE is needed for set_short_name(); GENERIC_READ and GENERIC_WRITE
1684          * are needed for adjust_compression_attribute().  */
1685         perms = GENERIC_READ | GENERIC_WRITE;
1686         if (!dentry_is_root(dentry))
1687                 perms |= DELETE;
1688
1689         /* FILE_ATTRIBUTE_SYSTEM is needed to ensure that
1690          * FILE_ATTRIBUTE_ENCRYPTED doesn't get set before we want it to be.  */
1691         status = create_file(&h, perms, NULL, FILE_ATTRIBUTE_SYSTEM,
1692                              FILE_OPEN_IF, FILE_DIRECTORY_FILE, dentry, ctx);
1693         if (unlikely(!NT_SUCCESS(status))) {
1694                 const wchar_t *path = current_path(ctx);
1695                 winnt_error(status, L"Can't create directory \"%ls\"", path);
1696
1697                 /* Check for known issue with WindowsApps directory.  */
1698                 if (status == STATUS_ACCESS_DENIED &&
1699                     (wcsstr(path, L"\\WindowsApps\\") ||
1700                      wcsstr(path, L"\\InfusedApps\\"))) {
1701                         ERROR(
1702 "You seem to be trying to extract files to the WindowsApps directory.\n"
1703 "        Windows 8.1 and later use new file permissions in this directory that\n"
1704 "        cannot be overridden, even by backup/restore programs.  To extract your\n"
1705 "        files anyway, you need to choose a different target directory, delete\n"
1706 "        the WindowsApps directory entirely, reformat the volume, do the\n"
1707 "        extraction from a non-broken operating system such as Windows 7 or\n"
1708 "        Linux, or wait for Microsoft to fix the design flaw in their operating\n"
1709 "        system.  This is *not* a bug in wimlib.  See this thread for more\n"
1710 "        information: https://wimlib.net/forums/viewtopic.php?f=1&t=261");
1711                 }
1712                 return WIMLIB_ERR_MKDIR;
1713         }
1714
1715         if (ctx->iosb.Information == FILE_OPENED) {
1716                 /* If we opened an existing directory, try to clear its file
1717                  * attributes.  As far as I know, this only actually makes a
1718                  * difference in the case where a FILE_ATTRIBUTE_READONLY
1719                  * directory has a named data stream which needs to be
1720                  * extracted.  You cannot create a named data stream of such a
1721                  * directory, even though this contradicts Microsoft's
1722                  * documentation for FILE_ATTRIBUTE_READONLY which states it is
1723                  * not honored for directories!  */
1724                 if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)) {
1725                         FILE_BASIC_INFORMATION basic_info =
1726                                 { .FileAttributes = FILE_ATTRIBUTE_NORMAL };
1727                         NtSetInformationFile(h, &ctx->iosb, &basic_info,
1728                                              sizeof(basic_info),
1729                                              FileBasicInformation);
1730                 }
1731         }
1732
1733         if (!dentry_is_root(dentry)) {
1734                 ret = set_short_name(h, dentry, ctx);
1735                 if (ret)
1736                         goto out;
1737         }
1738
1739         ret = adjust_compression_attribute(h, dentry, ctx);
1740 out:
1741         NtClose(h);
1742         return ret;
1743 }
1744
1745 /*
1746  * Create all the directories being extracted, other than the target directory
1747  * itself.
1748  *
1749  * Note: we don't honor directory hard links.  However, we don't allow them to
1750  * exist in WIM images anyway (see inode_fixup.c).
1751  */
1752 static int
1753 create_directories(struct list_head *dentry_list,
1754                    struct win32_apply_ctx *ctx)
1755 {
1756         const struct wim_dentry *dentry;
1757         int ret;
1758
1759         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
1760
1761                 if (!(dentry->d_inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY))
1762                         continue;
1763
1764                 /* Note: Here we include files with
1765                  * FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT, but we
1766                  * wait until later to actually set the reparse data.  */
1767
1768                 ret = create_directory(dentry, ctx);
1769
1770                 if (!ret)
1771                         ret = create_empty_streams(dentry, ctx);
1772
1773                 ret = check_apply_error(dentry, ctx, ret);
1774                 if (ret)
1775                         return ret;
1776
1777                 ret = report_file_created(&ctx->common);
1778                 if (ret)
1779                         return ret;
1780         }
1781         return 0;
1782 }
1783
1784 /*
1785  * Creates the nondirectory file named by @dentry.
1786  *
1787  * On success, returns an open handle to the file in @h_ret, with GENERIC_READ,
1788  * GENERIC_WRITE, and DELETE access.  Also, the path to the file will be saved
1789  * in ctx->pathbuf.  On failure, returns an error code.
1790  */
1791 static int
1792 create_nondirectory_inode(HANDLE *h_ret, const struct wim_dentry *dentry,
1793                           struct win32_apply_ctx *ctx)
1794 {
1795         int ret;
1796         HANDLE h;
1797
1798         build_extraction_path(dentry, ctx);
1799
1800         ret = supersede_file_or_stream(ctx,
1801                                        GENERIC_READ | GENERIC_WRITE | DELETE,
1802                                        &h);
1803         if (ret)
1804                 goto out;
1805
1806         ret = adjust_compression_attribute(h, dentry, ctx);
1807         if (ret)
1808                 goto out_close;
1809
1810         if (need_sparse_flag(dentry->d_inode, ctx)) {
1811                 ret = set_sparse_flag(h, ctx);
1812                 if (ret)
1813                         goto out_close;
1814         }
1815
1816         ret = create_empty_streams(dentry, ctx);
1817         if (ret)
1818                 goto out_close;
1819
1820         *h_ret = h;
1821         return 0;
1822
1823 out_close:
1824         NtClose(h);
1825 out:
1826         return ret;
1827 }
1828
1829 /* Creates a hard link at the location named by @dentry to the file represented
1830  * by the open handle @h.  Or, if the target volume does not support hard links,
1831  * create a separate file instead.  */
1832 static int
1833 create_link(HANDLE h, const struct wim_dentry *dentry,
1834             struct win32_apply_ctx *ctx)
1835 {
1836         if (ctx->common.supported_features.hard_links) {
1837
1838                 build_extraction_path(dentry, ctx);
1839
1840                 size_t bufsize = offsetof(FILE_LINK_INFORMATION, FileName) +
1841                                  ctx->pathbuf.Length + sizeof(wchar_t);
1842                 u8 buf[bufsize] _aligned_attribute(8);
1843                 FILE_LINK_INFORMATION *info = (FILE_LINK_INFORMATION *)buf;
1844                 NTSTATUS status;
1845
1846                 info->ReplaceIfExists = TRUE;
1847                 info->RootDirectory = ctx->attr.RootDirectory;
1848                 info->FileNameLength = ctx->pathbuf.Length;
1849                 memcpy(info->FileName, ctx->pathbuf.Buffer, ctx->pathbuf.Length);
1850                 info->FileName[info->FileNameLength / 2] = L'\0';
1851
1852                 /* Note: the null terminator isn't actually necessary,
1853                  * but if you don't add the extra character, you get
1854                  * STATUS_INFO_LENGTH_MISMATCH when FileNameLength
1855                  * happens to be 2  */
1856
1857                 status = NtSetInformationFile(h, &ctx->iosb, info, bufsize,
1858                                               FileLinkInformation);
1859                 if (NT_SUCCESS(status))
1860                         return 0;
1861                 winnt_error(status, L"Failed to create link \"%ls\"",
1862                             current_path(ctx));
1863                 return WIMLIB_ERR_LINK;
1864         } else {
1865                 HANDLE h2;
1866                 int ret;
1867
1868                 ret = create_nondirectory_inode(&h2, dentry, ctx);
1869                 if (ret)
1870                         return ret;
1871
1872                 NtClose(h2);
1873                 return 0;
1874         }
1875 }
1876
1877 /* Given an inode (represented by the open handle @h) for which one link has
1878  * been created (named by @first_dentry), create the other links.
1879  *
1880  * Or, if the target volume does not support hard links, create separate files.
1881  *
1882  * Note: This uses ctx->pathbuf and does not reset it.
1883  */
1884 static int
1885 create_links(HANDLE h, const struct wim_dentry *first_dentry,
1886              struct win32_apply_ctx *ctx)
1887 {
1888         const struct wim_inode *inode = first_dentry->d_inode;
1889         const struct wim_dentry *dentry;
1890         int ret;
1891
1892         inode_for_each_extraction_alias(dentry, inode) {
1893                 if (dentry != first_dentry) {
1894                         ret = create_link(h, dentry, ctx);
1895                         if (ret)
1896                                 return ret;
1897                 }
1898         }
1899         return 0;
1900 }
1901
1902 /* Create a nondirectory file, including all links.  */
1903 static int
1904 create_nondirectory(struct wim_inode *inode, struct win32_apply_ctx *ctx)
1905 {
1906         struct wim_dentry *first_dentry;
1907         HANDLE h;
1908         int ret;
1909
1910         first_dentry = first_extraction_alias(inode);
1911
1912         /* Create first link.  */
1913         ret = create_nondirectory_inode(&h, first_dentry, ctx);
1914         if (ret)
1915                 return ret;
1916
1917         /* Set short name.  */
1918         ret = set_short_name(h, first_dentry, ctx);
1919
1920         /* Create additional links, OR if hard links are not supported just
1921          * create more files.  */
1922         if (!ret)
1923                 ret = create_links(h, first_dentry, ctx);
1924
1925         /* "WIMBoot" extraction: set external backing by the WIM file if needed.  */
1926         if (!ret && unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT))
1927                 ret = set_backed_from_wim(h, inode, ctx);
1928
1929         NtClose(h);
1930         return ret;
1931 }
1932
1933 /* Create all the nondirectory files being extracted, including all aliases
1934  * (hard links).  */
1935 static int
1936 create_nondirectories(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
1937 {
1938         struct wim_dentry *dentry;
1939         struct wim_inode *inode;
1940         int ret;
1941
1942         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
1943                 inode = dentry->d_inode;
1944                 if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
1945                         continue;
1946                 /* Call create_nondirectory() only once per inode  */
1947                 if (dentry == inode_first_extraction_dentry(inode)) {
1948                         ret = create_nondirectory(inode, ctx);
1949                         ret = check_apply_error(dentry, ctx, ret);
1950                         if (ret)
1951                                 return ret;
1952                 }
1953                 ret = report_file_created(&ctx->common);
1954                 if (ret)
1955                         return ret;
1956         }
1957         return 0;
1958 }
1959
1960 static void
1961 close_handles(struct win32_apply_ctx *ctx)
1962 {
1963         for (unsigned i = 0; i < ctx->num_open_handles; i++)
1964                 NtClose(ctx->open_handles[i]);
1965 }
1966
1967 /* Prepare to read the next blob, which has size @blob_size, into an in-memory
1968  * buffer.  */
1969 static bool
1970 prepare_data_buffer(struct win32_apply_ctx *ctx, u64 blob_size)
1971 {
1972         if (blob_size > ctx->data_buffer_size) {
1973                 /* Larger buffer needed.  */
1974                 void *new_buffer;
1975                 if ((size_t)blob_size != blob_size)
1976                         return false;
1977                 new_buffer = REALLOC(ctx->data_buffer, blob_size);
1978                 if (!new_buffer)
1979                         return false;
1980                 ctx->data_buffer = new_buffer;
1981                 ctx->data_buffer_size = blob_size;
1982         }
1983         /* On the first call this changes data_buffer_ptr from NULL, which tells
1984          * extract_chunk() that the data buffer needs to be filled while reading
1985          * the stream data.  */
1986         ctx->data_buffer_ptr = ctx->data_buffer;
1987         return true;
1988 }
1989
1990 static int
1991 begin_extract_blob_instance(const struct blob_descriptor *blob,
1992                             struct wim_dentry *dentry,
1993                             const struct wim_inode_stream *strm,
1994                             struct win32_apply_ctx *ctx)
1995 {
1996         HANDLE h;
1997         NTSTATUS status;
1998
1999         if (unlikely(strm->stream_type == STREAM_TYPE_REPARSE_POINT)) {
2000                 /* We can't write the reparse point stream directly; we must set
2001                  * it with FSCTL_SET_REPARSE_POINT, which requires that all the
2002                  * data be available.  So, stage the data in a buffer.  */
2003                 if (!prepare_data_buffer(ctx, blob->size))
2004                         return WIMLIB_ERR_NOMEM;
2005                 list_add_tail(&dentry->d_tmp_list, &ctx->reparse_dentries);
2006                 return 0;
2007         }
2008
2009         if (unlikely(strm->stream_type == STREAM_TYPE_EFSRPC_RAW_DATA)) {
2010                 /* We can't write encrypted files directly; we must use
2011                  * WriteEncryptedFileRaw(), which requires providing the data
2012                  * through a callback function.  This can't easily be combined
2013                  * with our own callback-based approach.
2014                  *
2015                  * The current workaround is to simply read the blob into memory
2016                  * and write the encrypted file from that.
2017                  *
2018                  * TODO: This isn't sufficient for extremely large encrypted
2019                  * files.  Perhaps we should create an extra thread to write
2020                  * such files...  */
2021                 if (!prepare_data_buffer(ctx, blob->size))
2022                         return WIMLIB_ERR_NOMEM;
2023                 list_add_tail(&dentry->d_tmp_list, &ctx->encrypted_dentries);
2024                 return 0;
2025         }
2026
2027         /* It's a data stream (may be unnamed or named).  */
2028         wimlib_assert(strm->stream_type == STREAM_TYPE_DATA);
2029
2030         if (ctx->num_open_handles == MAX_OPEN_FILES) {
2031                 /* XXX: Fix this.  But because of the checks in
2032                  * extract_blob_list(), this can now only happen on a filesystem
2033                  * that does not support hard links.  */
2034                 ERROR("Can't extract data: too many open files!");
2035                 return WIMLIB_ERR_UNSUPPORTED;
2036         }
2037
2038
2039         if (unlikely(stream_is_named(strm))) {
2040                 build_extraction_path_with_ads(dentry, ctx,
2041                                                strm->stream_name,
2042                                                utf16le_len_chars(strm->stream_name));
2043         } else {
2044                 build_extraction_path(dentry, ctx);
2045         }
2046
2047
2048         /* Open a new handle  */
2049         status = do_create_file(&h,
2050                                 FILE_WRITE_DATA | SYNCHRONIZE,
2051                                 NULL, 0, FILE_OPEN_IF,
2052                                 FILE_SEQUENTIAL_ONLY |
2053                                         FILE_SYNCHRONOUS_IO_NONALERT,
2054                                 ctx);
2055         if (!NT_SUCCESS(status)) {
2056                 winnt_error(status, L"Can't open \"%ls\" for writing",
2057                             current_path(ctx));
2058                 return WIMLIB_ERR_OPEN;
2059         }
2060
2061         ctx->is_sparse_stream[ctx->num_open_handles] = false;
2062         if (need_sparse_flag(dentry->d_inode, ctx)) {
2063                 /* If the stream is unnamed, then the sparse flag was already
2064                  * set when the file was created.  But if the stream is named,
2065                  * then we need to set the sparse flag here. */
2066                 if (unlikely(stream_is_named(strm))) {
2067                         int ret = set_sparse_flag(h, ctx);
2068                         if (ret) {
2069                                 NtClose(h);
2070                                 return ret;
2071                         }
2072                 }
2073                 ctx->is_sparse_stream[ctx->num_open_handles] = true;
2074                 ctx->any_sparse_streams = true;
2075         } else {
2076                 /* Allocate space for the data.  */
2077                 FILE_ALLOCATION_INFORMATION info =
2078                         { .AllocationSize = { .QuadPart = blob->size }};
2079                 NtSetInformationFile(h, &ctx->iosb, &info, sizeof(info),
2080                                      FileAllocationInformation);
2081         }
2082         ctx->open_handles[ctx->num_open_handles++] = h;
2083         return 0;
2084 }
2085
2086 /* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
2087  * pointer to the suffix of the path that begins with the device directly, such
2088  * as e:\Windows\System32.  */
2089 static const wchar_t *
2090 skip_nt_toplevel_component(const wchar_t *path, size_t path_nchars)
2091 {
2092         static const wchar_t * const dirs[] = {
2093                 L"\\??\\",
2094                 L"\\DosDevices\\",
2095                 L"\\Device\\",
2096         };
2097         const wchar_t * const end = path + path_nchars;
2098
2099         for (size_t i = 0; i < ARRAY_LEN(dirs); i++) {
2100                 size_t len = wcslen(dirs[i]);
2101                 if (len <= (end - path) && !wmemcmp(path, dirs[i], len)) {
2102                         path += len;
2103                         while (path != end && *path == L'\\')
2104                                 path++;
2105                         return path;
2106                 }
2107         }
2108         return path;
2109 }
2110
2111 /*
2112  * Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
2113  * pointer to the suffix of the path that is device-relative but possibly with
2114  * leading slashes, such as \Windows\System32.
2115  *
2116  * The path has an explicit length and is not necessarily null terminated.
2117  */
2118 static const wchar_t *
2119 get_device_relative_path(const wchar_t *path, size_t path_nchars)
2120 {
2121         const wchar_t * const orig_path = path;
2122         const wchar_t * const end = path + path_nchars;
2123
2124         path = skip_nt_toplevel_component(path, path_nchars);
2125         if (path == orig_path)
2126                 return orig_path;
2127
2128         while (path != end && *path != L'\\')
2129                 path++;
2130
2131         return path;
2132 }
2133
2134 /*
2135  * Given a reparse point buffer for an inode for which the absolute link target
2136  * was relativized when it was archived, de-relative the link target to be
2137  * consistent with the actual extraction location.
2138  */
2139 static void
2140 try_rpfix(struct reparse_buffer_disk *rpbuf, u16 *rpbuflen_p,
2141           struct win32_apply_ctx *ctx)
2142 {
2143         struct link_reparse_point link;
2144         size_t orig_subst_name_nchars;
2145         const wchar_t *relpath;
2146         size_t relpath_nchars;
2147         size_t target_ntpath_nchars;
2148         size_t fixed_subst_name_nchars;
2149         const wchar_t *fixed_print_name;
2150         size_t fixed_print_name_nchars;
2151
2152         /* Do nothing if the reparse data is invalid.  */
2153         if (parse_link_reparse_point(rpbuf, *rpbuflen_p, &link))
2154                 return;
2155
2156         /* Do nothing if the reparse point is a relative symbolic link.  */
2157         if (link_is_relative_symlink(&link))
2158                 return;
2159
2160         /* Build the new substitute name from the NT namespace path to the
2161          * target directory, then a path separator, then the "device relative"
2162          * part of the old substitute name.  */
2163
2164         orig_subst_name_nchars = link.substitute_name_nbytes / sizeof(wchar_t);
2165
2166         relpath = get_device_relative_path(link.substitute_name,
2167                                            orig_subst_name_nchars);
2168         relpath_nchars = orig_subst_name_nchars -
2169                          (relpath - link.substitute_name);
2170
2171         target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t);
2172
2173         /* If the target directory is a filesystem root, such as \??\C:\, then
2174          * it already will have a trailing slash.  Don't include this slash if
2175          * we are already adding slashes via 'relpath'.  This prevents an extra
2176          * slash from being generated each time the link is extracted.  And
2177          * unlike on UNIX, the number of slashes in paths on Windows can be
2178          * significant; Windows won't understand the link target if it contains
2179          * too many slashes.  */
2180         if (target_ntpath_nchars > 0 && relpath_nchars > 0 &&
2181             ctx->target_ntpath.Buffer[target_ntpath_nchars - 1] == L'\\')
2182                 target_ntpath_nchars--;
2183
2184         /* Also remove extra slashes from the beginning of 'relpath'.  Normally
2185          * this isn't needed, but this is here to make the extra slash(es) added
2186          * by wimlib pre-v1.9.1 get removed automatically.  */
2187         while (relpath_nchars >= 2 &&
2188                relpath[0] == L'\\' && relpath[1] == L'\\') {
2189                 relpath++;
2190                 relpath_nchars--;
2191         }
2192
2193         fixed_subst_name_nchars = target_ntpath_nchars + relpath_nchars;
2194
2195         wchar_t fixed_subst_name[fixed_subst_name_nchars];
2196
2197         wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer, target_ntpath_nchars);
2198         wmemcpy(&fixed_subst_name[target_ntpath_nchars], relpath, relpath_nchars);
2199         /* Doesn't need to be null-terminated.  */
2200
2201         /* Print name should be Win32, but not all NT names can even be
2202          * translated to Win32 names.  But we can at least delete the top-level
2203          * directory, such as \??\, and this will have the expected result in
2204          * the usual case.  */
2205         fixed_print_name = skip_nt_toplevel_component(fixed_subst_name,
2206                                                       fixed_subst_name_nchars);
2207         fixed_print_name_nchars = fixed_subst_name_nchars - (fixed_print_name -
2208                                                              fixed_subst_name);
2209
2210         link.substitute_name = fixed_subst_name;
2211         link.substitute_name_nbytes = fixed_subst_name_nchars * sizeof(wchar_t);
2212         link.print_name = (wchar_t *)fixed_print_name;
2213         link.print_name_nbytes = fixed_print_name_nchars * sizeof(wchar_t);
2214         make_link_reparse_point(&link, rpbuf, rpbuflen_p);
2215 }
2216
2217 /* Sets the reparse point on the specified file.  This handles "fixing" the
2218  * targets of absolute symbolic links and junctions if WIMLIB_EXTRACT_FLAG_RPFIX
2219  * was specified.  */
2220 static int
2221 set_reparse_point(const struct wim_dentry *dentry,
2222                   const struct reparse_buffer_disk *rpbuf, u16 rpbuflen,
2223                   struct win32_apply_ctx *ctx)
2224 {
2225         if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX)
2226             && !(dentry->d_inode->i_rp_flags & WIM_RP_FLAG_NOT_FIXED))
2227         {
2228                 memcpy(&ctx->rpfixbuf, rpbuf, rpbuflen);
2229                 try_rpfix(&ctx->rpfixbuf, &rpbuflen, ctx);
2230                 rpbuf = &ctx->rpfixbuf;
2231         }
2232         return do_set_reparse_point(dentry, rpbuf, rpbuflen, ctx);
2233
2234 }
2235
2236 /* Import the next block of raw encrypted data  */
2237 static DWORD WINAPI
2238 import_encrypted_data(PBYTE pbData, PVOID pvCallbackContext, PULONG Length)
2239 {
2240         struct win32_apply_ctx *ctx = pvCallbackContext;
2241         ULONG copy_len;
2242
2243         copy_len = min(ctx->encrypted_size - ctx->encrypted_offset, *Length);
2244         memcpy(pbData, &ctx->data_buffer[ctx->encrypted_offset], copy_len);
2245         ctx->encrypted_offset += copy_len;
2246         *Length = copy_len;
2247         return ERROR_SUCCESS;
2248 }
2249
2250 /*
2251  * Write the raw encrypted data to the already-created file (or directory)
2252  * corresponding to @dentry.
2253  *
2254  * The raw encrypted data is provided in ctx->data_buffer, and its size is
2255  * ctx->encrypted_size.
2256  *
2257  * This function may close the target directory, in which case the caller needs
2258  * to re-open it if needed.
2259  */
2260 static int
2261 extract_encrypted_file(const struct wim_dentry *dentry,
2262                        struct win32_apply_ctx *ctx)
2263 {
2264         void *rawctx;
2265         DWORD err;
2266         ULONG flags;
2267         bool retried;
2268
2269         /* Temporarily build a Win32 path for OpenEncryptedFileRaw()  */
2270         build_win32_extraction_path(dentry, ctx);
2271
2272         flags = CREATE_FOR_IMPORT | OVERWRITE_HIDDEN;
2273         if (dentry->d_inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
2274                 flags |= CREATE_FOR_DIR;
2275
2276         retried = false;
2277 retry:
2278         err = OpenEncryptedFileRaw(ctx->pathbuf.Buffer, flags, &rawctx);
2279         if (err == ERROR_SHARING_VIOLATION && !retried) {
2280                 /* This can be caused by the handle we have open to the target
2281                  * directory.  Try closing it temporarily.  */
2282                 close_target_directory(ctx);
2283                 retried = true;
2284                 goto retry;
2285         }
2286
2287         /* Restore the NT namespace path  */
2288         build_extraction_path(dentry, ctx);
2289
2290         if (err != ERROR_SUCCESS) {
2291                 win32_error(err, L"Can't open \"%ls\" for encrypted import",
2292                             current_path(ctx));
2293                 return WIMLIB_ERR_OPEN;
2294         }
2295
2296         ctx->encrypted_offset = 0;
2297
2298         err = WriteEncryptedFileRaw(import_encrypted_data, ctx, rawctx);
2299
2300         CloseEncryptedFileRaw(rawctx);
2301
2302         if (err != ERROR_SUCCESS) {
2303                 win32_error(err, L"Can't import encrypted file \"%ls\"",
2304                             current_path(ctx));
2305                 return WIMLIB_ERR_WRITE;
2306         }
2307
2308         return 0;
2309 }
2310
2311 /* Called when starting to read a blob for extraction */
2312 static int
2313 win32_begin_extract_blob(struct blob_descriptor *blob, void *_ctx)
2314 {
2315         struct win32_apply_ctx *ctx = _ctx;
2316         const struct blob_extraction_target *targets = blob_extraction_targets(blob);
2317         int ret;
2318
2319         ctx->num_open_handles = 0;
2320         ctx->data_buffer_ptr = NULL;
2321         ctx->any_sparse_streams = false;
2322         INIT_LIST_HEAD(&ctx->reparse_dentries);
2323         INIT_LIST_HEAD(&ctx->encrypted_dentries);
2324
2325         for (u32 i = 0; i < blob->out_refcnt; i++) {
2326                 const struct wim_inode *inode = targets[i].inode;
2327                 const struct wim_inode_stream *strm = targets[i].stream;
2328                 struct wim_dentry *dentry;
2329
2330                 /* A copy of the blob needs to be extracted to @inode.  */
2331
2332                 if (ctx->common.supported_features.hard_links) {
2333                         dentry = inode_first_extraction_dentry(inode);
2334                         ret = begin_extract_blob_instance(blob, dentry, strm, ctx);
2335                         ret = check_apply_error(dentry, ctx, ret);
2336                         if (ret)
2337                                 goto fail;
2338                 } else {
2339                         /* Hard links not supported.  Extract the blob
2340                          * separately to each alias of the inode.  */
2341                         inode_for_each_extraction_alias(dentry, inode) {
2342                                 ret = begin_extract_blob_instance(blob, dentry, strm, ctx);
2343                                 ret = check_apply_error(dentry, ctx, ret);
2344                                 if (ret)
2345                                         goto fail;
2346                         }
2347                 }
2348         }
2349
2350         return 0;
2351
2352 fail:
2353         close_handles(ctx);
2354         return ret;
2355 }
2356
2357 static int
2358 pwrite_to_handle(HANDLE h, const void *data, size_t size, u64 offset)
2359 {
2360         const void * const end = data + size;
2361         const void *p;
2362         IO_STATUS_BLOCK iosb;
2363         NTSTATUS status;
2364
2365         for (p = data; p != end; p += iosb.Information,
2366                                  offset += iosb.Information)
2367         {
2368                 LARGE_INTEGER offs = { .QuadPart = offset };
2369
2370                 status = NtWriteFile(h, NULL, NULL, NULL, &iosb,
2371                                      (void *)p, min(INT32_MAX, end - p),
2372                                      &offs, NULL);
2373                 if (!NT_SUCCESS(status)) {
2374                         winnt_error(status,
2375                                     L"Error writing data to target volume");
2376                         return WIMLIB_ERR_WRITE;
2377                 }
2378         }
2379         return 0;
2380 }
2381
2382 /* Called when the next chunk of a blob has been read for extraction */
2383 static int
2384 win32_extract_chunk(const struct blob_descriptor *blob, u64 offset,
2385                     const void *chunk, size_t size, void *_ctx)
2386 {
2387         struct win32_apply_ctx *ctx = _ctx;
2388         const void * const end = chunk + size;
2389         const void *p;
2390         bool zeroes;
2391         size_t len;
2392         unsigned i;
2393         int ret;
2394
2395         /*
2396          * For sparse streams, only write nonzero regions.  This lets the
2397          * filesystem use holes to represent zero regions.
2398          */
2399         for (p = chunk; p != end; p += len, offset += len) {
2400                 zeroes = maybe_detect_sparse_region(p, end - p, &len,
2401                                                     ctx->any_sparse_streams);
2402                 for (i = 0; i < ctx->num_open_handles; i++) {
2403                         if (!zeroes || !ctx->is_sparse_stream[i]) {
2404                                 ret = pwrite_to_handle(ctx->open_handles[i],
2405                                                        p, len, offset);
2406                                 if (ret)
2407                                         return ret;
2408                         }
2409                 }
2410         }
2411
2412         /* Copy the data chunk into the buffer (if needed)  */
2413         if (ctx->data_buffer_ptr)
2414                 ctx->data_buffer_ptr = mempcpy(ctx->data_buffer_ptr,
2415                                                chunk, size);
2416         return 0;
2417 }
2418
2419 static int
2420 get_system_compression_format(int extract_flags)
2421 {
2422         if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K)
2423                 return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K;
2424
2425         if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K)
2426                 return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS8K;
2427
2428         if (extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K)
2429                 return FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS16K;
2430
2431         return FILE_PROVIDER_COMPRESSION_FORMAT_LZX;
2432 }
2433
2434
2435 static const wchar_t *
2436 get_system_compression_format_string(int format)
2437 {
2438         switch (format) {
2439         case FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K:
2440                 return L"XPRESS4K";
2441         case FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS8K:
2442                 return L"XPRESS8K";
2443         case FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS16K:
2444                 return L"XPRESS16K";
2445         default:
2446                 return L"LZX";
2447         }
2448 }
2449
2450 static NTSTATUS
2451 set_system_compression(HANDLE h, int format)
2452 {
2453         NTSTATUS status;
2454         struct {
2455                 struct wof_external_info wof_info;
2456                 struct file_provider_external_info file_info;
2457         } in = {
2458                 .wof_info = {
2459                         .version = WOF_CURRENT_VERSION,
2460                         .provider = WOF_PROVIDER_FILE,
2461                 },
2462                 .file_info = {
2463                         .version = FILE_PROVIDER_CURRENT_VERSION,
2464                         .compression_format = format,
2465                 },
2466         };
2467
2468         /* We intentionally use NtFsControlFile() rather than DeviceIoControl()
2469          * here because the "compressing this object would not save space"
2470          * status code does not map to a valid Win32 error code on older
2471          * versions of Windows (before Windows 10?).  This can be a problem if
2472          * the WOFADK driver is being used rather than the regular WOF, since
2473          * WOFADK can be used on older versions of Windows.  */
2474         status = winnt_fsctl(h, FSCTL_SET_EXTERNAL_BACKING,
2475                              &in, sizeof(in), NULL, 0, NULL);
2476
2477         if (status == 0xC000046F) /* "Compressing this object would not save space."  */
2478                 return STATUS_SUCCESS;
2479
2480         return status;
2481 }
2482
2483 /* Hard-coded list of files which the Windows bootloader may need to access
2484  * before the WOF driver has been loaded.  */
2485 static const wchar_t * const bootloader_pattern_strings[] = {
2486         L"*winload.*",
2487         L"*winresume.*",
2488         L"\\Windows\\AppPatch\\drvmain.sdb",
2489         L"\\Windows\\Boot\\DVD\\*",
2490         L"\\Windows\\Boot\\EFI\\*",
2491         L"\\Windows\\bootstat.dat",
2492         L"\\Windows\\Fonts\\vgaoem.fon",
2493         L"\\Windows\\Fonts\\vgasys.fon",
2494         L"\\Windows\\INF\\errata.inf",
2495         L"\\Windows\\System32\\config\\*",
2496         L"\\Windows\\System32\\ntkrnlpa.exe",
2497         L"\\Windows\\System32\\ntoskrnl.exe",
2498         L"\\Windows\\System32\\bootvid.dll",
2499         L"\\Windows\\System32\\ci.dll",
2500         L"\\Windows\\System32\\hal*.dll",
2501         L"\\Windows\\System32\\mcupdate_AuthenticAMD.dll",
2502         L"\\Windows\\System32\\mcupdate_GenuineIntel.dll",
2503         L"\\Windows\\System32\\pshed.dll",
2504         L"\\Windows\\System32\\apisetschema.dll",
2505         L"\\Windows\\System32\\api-ms-win*.dll",
2506         L"\\Windows\\System32\\ext-ms-win*.dll",
2507         L"\\Windows\\System32\\KernelBase.dll",
2508         L"\\Windows\\System32\\drivers\\*.sys",
2509         L"\\Windows\\System32\\*.nls",
2510         L"\\Windows\\System32\\kbd*.dll",
2511         L"\\Windows\\System32\\kd*.dll",
2512         L"\\Windows\\System32\\clfs.sys",
2513         L"\\Windows\\System32\\CodeIntegrity\\driver.stl",
2514 };
2515
2516 static const struct string_list bootloader_patterns = {
2517         .strings = (wchar_t **)bootloader_pattern_strings,
2518         .num_strings = ARRAY_LEN(bootloader_pattern_strings),
2519 };
2520
2521 static NTSTATUS
2522 set_system_compression_on_inode(struct wim_inode *inode, int format,
2523                                 struct win32_apply_ctx *ctx)
2524 {
2525         bool retried = false;
2526         NTSTATUS status;
2527         HANDLE h;
2528
2529         /* If it may be needed for compatibility with the Windows bootloader,
2530          * force this file to XPRESS4K or uncompressed format.  The bootloader
2531          * of Windows 10 supports XPRESS4K only; older versions don't support
2532          * system compression at all.  */
2533         if (!is_image_windows_10_or_later(ctx) ||
2534             format != FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K)
2535         {
2536                 /* We need to check the patterns against every name of the
2537                  * inode, in case any of them match.  */
2538                 struct wim_dentry *dentry;
2539                 inode_for_each_extraction_alias(dentry, inode) {
2540                         bool incompatible;
2541                         bool warned;
2542
2543                         if (calculate_dentry_full_path(dentry)) {
2544                                 ERROR("Unable to compute file path!");
2545                                 return STATUS_NO_MEMORY;
2546                         }
2547
2548                         incompatible = match_pattern_list(dentry->d_full_path,
2549                                                           &bootloader_patterns);
2550                         FREE(dentry->d_full_path);
2551                         dentry->d_full_path = NULL;
2552
2553                         if (!incompatible)
2554                                 continue;
2555
2556                         warned = (ctx->num_system_compression_exclusions++ > 0);
2557
2558                         if (is_image_windows_10_or_later(ctx)) {
2559                                 /* Force to XPRESS4K  */
2560                                 if (!warned) {
2561                                         WARNING("For compatibility with the "
2562                                                 "Windows bootloader, some "
2563                                                 "files are being\n"
2564                                                 "          compacted "
2565                                                 "using the XPRESS4K format "
2566                                                 "instead of the %"TS" format\n"
2567                                                 "          you requested.",
2568                                                 get_system_compression_format_string(format));
2569                                 }
2570                                 format = FILE_PROVIDER_COMPRESSION_FORMAT_XPRESS4K;
2571                                 break;
2572                         } else {
2573                                 /* Force to uncompressed  */
2574                                 if (!warned) {
2575                                         WARNING("For compatibility with the "
2576                                                 "Windows bootloader, some "
2577                                                 "files will not\n"
2578                                                 "          be compressed with"
2579                                                 " system compression "
2580                                                 "(\"compacted\").");
2581                                 }
2582                                 return STATUS_SUCCESS;
2583                         }
2584
2585                 }
2586         }
2587
2588         /* Open the extracted file.  */
2589         status = create_file(&h, GENERIC_READ | GENERIC_WRITE, NULL,
2590                              0, FILE_OPEN, 0,
2591                              inode_first_extraction_dentry(inode), ctx);
2592
2593         if (!NT_SUCCESS(status))
2594                 return status;
2595 retry:
2596         /* Compress the file.  If the attempt fails with "invalid device
2597          * request", then attach wof.sys (or wofadk.sys) and retry.  */
2598         status = set_system_compression(h, format);
2599         if (unlikely(status == STATUS_INVALID_DEVICE_REQUEST && !retried)) {
2600                 wchar_t drive_path[7];
2601                 if (!win32_get_drive_path(ctx->common.target, drive_path) &&
2602                     win32_try_to_attach_wof(drive_path + 4)) {
2603                         retried = true;
2604                         goto retry;
2605                 }
2606         }
2607
2608         NtClose(h);
2609         return status;
2610 }
2611
2612 /*
2613  * This function is called when doing a "compact-mode" extraction and we just
2614  * finished extracting a blob to one or more locations.  For each location that
2615  * was the unnamed data stream of a file, this function compresses the
2616  * corresponding file using System Compression, if allowed.
2617  *
2618  * Note: we're doing the compression immediately after extracting the data
2619  * rather than during a separate compression pass.  This way should be faster
2620  * since the operating system should still have the file's data cached.
2621  *
2622  * Note: we're having the operating system do the compression, which is not
2623  * ideal because wimlib could create the compressed data faster and more
2624  * efficiently (the compressed data format is identical to a WIM resource).  But
2625  * we seemingly don't have a choice because WOF prevents applications from
2626  * creating its reparse points.
2627  */
2628 static void
2629 handle_system_compression(struct blob_descriptor *blob, struct win32_apply_ctx *ctx)
2630 {
2631         const struct blob_extraction_target *targets = blob_extraction_targets(blob);
2632
2633         const int format = get_system_compression_format(ctx->common.extract_flags);
2634
2635         for (u32 i = 0; i < blob->out_refcnt; i++) {
2636                 struct wim_inode *inode = targets[i].inode;
2637                 struct wim_inode_stream *strm = targets[i].stream;
2638                 NTSTATUS status;
2639
2640                 if (!stream_is_unnamed_data_stream(strm))
2641                         continue;
2642
2643                 if (will_externally_back_inode(inode, ctx, NULL, false) != 0)
2644                         continue;
2645
2646                 status = set_system_compression_on_inode(inode, format, ctx);
2647                 if (likely(NT_SUCCESS(status)))
2648                         continue;
2649
2650                 if (status == STATUS_INVALID_DEVICE_REQUEST) {
2651                         WARNING(
2652           "The request to compress the extracted files using System Compression\n"
2653 "          will not be honored because the operating system or target volume\n"
2654 "          does not support it.  System Compression is only supported on\n"
2655 "          Windows 10 and later, and only on NTFS volumes.");
2656                         ctx->common.extract_flags &= ~COMPACT_FLAGS;
2657                         return;
2658                 }
2659
2660                 ctx->num_system_compression_failures++;
2661                 if (ctx->num_system_compression_failures < 10) {
2662                         winnt_warning(status, L"\"%ls\": Failed to compress "
2663                                       "extracted file using System Compression",
2664                                       current_path(ctx));
2665                 } else if (ctx->num_system_compression_failures == 10) {
2666                         WARNING("Suppressing further warnings about "
2667                                 "System Compression failures.");
2668                 }
2669         }
2670 }
2671
2672 /* Called when a blob has been fully read for extraction */
2673 static int
2674 win32_end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
2675 {
2676         struct win32_apply_ctx *ctx = _ctx;
2677         int ret;
2678         const struct wim_dentry *dentry;
2679
2680         /* Extend sparse streams to their final size. */
2681         if (ctx->any_sparse_streams && !status) {
2682                 for (unsigned i = 0; i < ctx->num_open_handles; i++) {
2683                         FILE_END_OF_FILE_INFORMATION info =
2684                                 { .EndOfFile = { .QuadPart = blob->size } };
2685                         NTSTATUS ntstatus;
2686
2687                         if (!ctx->is_sparse_stream[i])
2688                                 continue;
2689
2690                         ntstatus = NtSetInformationFile(ctx->open_handles[i],
2691                                                         &ctx->iosb,
2692                                                         &info, sizeof(info),
2693                                                         FileEndOfFileInformation);
2694                         if (!NT_SUCCESS(ntstatus)) {
2695                                 winnt_error(ntstatus, L"Error writing data to "
2696                                             "target volume (while extending)");
2697                                 status = WIMLIB_ERR_WRITE;
2698                                 break;
2699                         }
2700                 }
2701         }
2702
2703         close_handles(ctx);
2704
2705         if (status)
2706                 return status;
2707
2708         if (unlikely(ctx->common.extract_flags & COMPACT_FLAGS))
2709                 handle_system_compression(blob, ctx);
2710
2711         if (likely(!ctx->data_buffer_ptr))
2712                 return 0;
2713
2714         if (!list_empty(&ctx->reparse_dentries)) {
2715                 if (blob->size > REPARSE_DATA_MAX_SIZE) {
2716                         dentry = list_first_entry(&ctx->reparse_dentries,
2717                                                   struct wim_dentry, d_tmp_list);
2718                         build_extraction_path(dentry, ctx);
2719                         ERROR("Reparse data of \"%ls\" has size "
2720                               "%"PRIu64" bytes (exceeds %u bytes)",
2721                               current_path(ctx), blob->size,
2722                               REPARSE_DATA_MAX_SIZE);
2723                         ret = WIMLIB_ERR_INVALID_REPARSE_DATA;
2724                         return check_apply_error(dentry, ctx, ret);
2725                 }
2726                 /* Reparse data  */
2727                 memcpy(ctx->rpbuf.rpdata, ctx->data_buffer, blob->size);
2728
2729                 list_for_each_entry(dentry, &ctx->reparse_dentries, d_tmp_list) {
2730
2731                         /* Reparse point header  */
2732                         complete_reparse_point(&ctx->rpbuf, dentry->d_inode,
2733                                                blob->size);
2734
2735                         ret = set_reparse_point(dentry, &ctx->rpbuf,
2736                                                 REPARSE_DATA_OFFSET + blob->size,
2737                                                 ctx);
2738                         ret = check_apply_error(dentry, ctx, ret);
2739                         if (ret)
2740                                 return ret;
2741                 }
2742         }
2743
2744         if (!list_empty(&ctx->encrypted_dentries)) {
2745                 ctx->encrypted_size = blob->size;
2746                 list_for_each_entry(dentry, &ctx->encrypted_dentries, d_tmp_list) {
2747                         ret = extract_encrypted_file(dentry, ctx);
2748                         ret = check_apply_error(dentry, ctx, ret);
2749                         if (ret)
2750                                 return ret;
2751                         /* Re-open the target directory if needed.  */
2752                         ret = open_target_directory(ctx);
2753                         if (ret)
2754                                 return ret;
2755                 }
2756         }
2757
2758         return 0;
2759 }
2760
2761 /* Attributes that can't be set directly  */
2762 #define SPECIAL_ATTRIBUTES                      \
2763         (FILE_ATTRIBUTE_REPARSE_POINT   |       \
2764          FILE_ATTRIBUTE_DIRECTORY       |       \
2765          FILE_ATTRIBUTE_ENCRYPTED       |       \
2766          FILE_ATTRIBUTE_SPARSE_FILE     |       \
2767          FILE_ATTRIBUTE_COMPRESSED)
2768
2769 static void
2770 set_object_id(HANDLE h, const struct wim_inode *inode,
2771               struct win32_apply_ctx *ctx)
2772 {
2773         const void *object_id;
2774         u32 len;
2775         NTSTATUS status;
2776
2777         if (!ctx->common.supported_features.object_ids)
2778                 return;
2779
2780         object_id = inode_get_object_id(inode, &len);
2781         if (likely(object_id == NULL))  /* No object ID?  */
2782                 return;
2783
2784         status = winnt_fsctl(h, FSCTL_SET_OBJECT_ID,
2785                              object_id, len, NULL, 0, NULL);
2786         if (NT_SUCCESS(status))
2787                 return;
2788
2789         /* Object IDs must be unique within the filesystem.  A duplicate might
2790          * occur if an image containing object IDs is applied twice to the same
2791          * filesystem.  Arguably, the user should be warned in this case; but
2792          * the reality seems to be that nothing important cares about object IDs
2793          * except the Distributed Link Tracking Service... so for now these
2794          * failures are just ignored.  */
2795         if (status == STATUS_DUPLICATE_NAME ||
2796             status == STATUS_OBJECT_NAME_COLLISION)
2797                 return;
2798
2799         ctx->num_object_id_failures++;
2800         if (ctx->num_object_id_failures < 10) {
2801                 winnt_warning(status, L"Can't set object ID on \"%ls\"",
2802                               current_path(ctx));
2803         } else if (ctx->num_object_id_failures == 10) {
2804                 WARNING("Suppressing further warnings about failure to set "
2805                         "object IDs.");
2806         }
2807 }
2808
2809 /* Set the security descriptor @desc, of @desc_size bytes, on the file with open
2810  * handle @h.  */
2811 static NTSTATUS
2812 set_security_descriptor(HANDLE h, const void *_desc,
2813                         size_t desc_size, struct win32_apply_ctx *ctx)
2814 {
2815         SECURITY_INFORMATION info;
2816         NTSTATUS status;
2817         SECURITY_DESCRIPTOR_RELATIVE *desc;
2818
2819         /*
2820          * Ideally, we would just pass in the security descriptor buffer as-is.
2821          * But it turns out that Windows can mess up the security descriptor
2822          * even when using the low-level NtSetSecurityObject() function:
2823          *
2824          * - Windows will clear SE_DACL_AUTO_INHERITED if it is set in the
2825          *   passed buffer.  To actually get Windows to set
2826          *   SE_DACL_AUTO_INHERITED, the application must set the non-persistent
2827          *   flag SE_DACL_AUTO_INHERIT_REQ.  As usual, Microsoft didn't bother
2828          *   to properly document either of these flags.  It's unclear how
2829          *   important SE_DACL_AUTO_INHERITED actually is, but to be safe we use
2830          *   the SE_DACL_AUTO_INHERIT_REQ workaround to set it if needed.
2831          *
2832          * - The above also applies to the equivalent SACL flags,
2833          *   SE_SACL_AUTO_INHERITED and SE_SACL_AUTO_INHERIT_REQ.
2834          *
2835          * - If the application says that it's setting
2836          *   DACL_SECURITY_INFORMATION, then Windows sets SE_DACL_PRESENT in the
2837          *   resulting security descriptor, even if the security descriptor the
2838          *   application provided did not have a DACL.  This seems to be
2839          *   unavoidable, since omitting DACL_SECURITY_INFORMATION would cause a
2840          *   default DACL to remain.  Fortunately, this behavior seems harmless,
2841          *   since the resulting DACL will still be "null" --- but it will be
2842          *   "the other representation of null".
2843          *
2844          * - The above also applies to SACL_SECURITY_INFORMATION and
2845          *   SE_SACL_PRESENT.  Again, it's seemingly unavoidable but "harmless"
2846          *   that Windows changes the representation of a "null SACL".
2847          */
2848         if (likely(desc_size <= STACK_MAX)) {
2849                 desc = alloca(desc_size);
2850         } else {
2851                 desc = MALLOC(desc_size);
2852                 if (!desc)
2853                         return STATUS_NO_MEMORY;
2854         }
2855
2856         memcpy(desc, _desc, desc_size);
2857
2858         if (likely(desc_size >= 4)) {
2859
2860                 if (desc->Control & SE_DACL_AUTO_INHERITED)
2861                         desc->Control |= SE_DACL_AUTO_INHERIT_REQ;
2862
2863                 if (desc->Control & SE_SACL_AUTO_INHERITED)
2864                         desc->Control |= SE_SACL_AUTO_INHERIT_REQ;
2865         }
2866
2867         /*
2868          * More API insanity.  We want to set the entire security descriptor
2869          * as-is.  But all available APIs require specifying the specific parts
2870          * of the security descriptor being set.  Especially annoying is that
2871          * mandatory integrity labels are part of the SACL, but they aren't set
2872          * with SACL_SECURITY_INFORMATION.  Instead, applications must also
2873          * specify LABEL_SECURITY_INFORMATION (Windows Vista, Windows 7) or
2874          * BACKUP_SECURITY_INFORMATION (Windows 8).  But at least older versions
2875          * of Windows don't error out if you provide these newer flags...
2876          *
2877          * Also, if the process isn't running as Administrator, then it probably
2878          * doesn't have SE_RESTORE_PRIVILEGE.  In this case, it will always get
2879          * the STATUS_PRIVILEGE_NOT_HELD error by trying to set the SACL, even
2880          * if the security descriptor it provided did not have a SACL.  By
2881          * default, in this case we try to recover and set as much of the
2882          * security descriptor as possible --- potentially excluding the DACL, and
2883          * even the owner, as well as the SACL.
2884          */
2885
2886         info = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
2887                DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION |
2888                LABEL_SECURITY_INFORMATION | BACKUP_SECURITY_INFORMATION;
2889
2890
2891         /*
2892          * It's also worth noting that SetFileSecurity() is unusable because it
2893          * doesn't request "backup semantics" when it opens the file internally.
2894          * NtSetSecurityObject() seems to be the best function to use in backup
2895          * applications.  (SetSecurityInfo() should also work, but it's harder
2896          * to use and must call NtSetSecurityObject() internally anyway.
2897          * BackupWrite() is theoretically usable as well, but it's inflexible
2898          * and poorly documented.)
2899          */
2900
2901 retry:
2902         status = NtSetSecurityObject(h, info, desc);
2903         if (NT_SUCCESS(status))
2904                 goto out_maybe_free_desc;
2905
2906         /* Failed to set the requested parts of the security descriptor.  If the
2907          * error was permissions-related, try to set fewer parts of the security
2908          * descriptor, unless WIMLIB_EXTRACT_FLAG_STRICT_ACLS is enabled.  */
2909         if ((status == STATUS_PRIVILEGE_NOT_HELD ||
2910              status == STATUS_ACCESS_DENIED) &&
2911             !(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS))
2912         {
2913                 if (info & SACL_SECURITY_INFORMATION) {
2914                         info &= ~(SACL_SECURITY_INFORMATION |
2915                                   LABEL_SECURITY_INFORMATION |
2916                                   BACKUP_SECURITY_INFORMATION);
2917                         ctx->partial_security_descriptors++;
2918                         goto retry;
2919                 }
2920                 if (info & DACL_SECURITY_INFORMATION) {
2921                         info &= ~DACL_SECURITY_INFORMATION;
2922                         goto retry;
2923                 }
2924                 if (info & OWNER_SECURITY_INFORMATION) {
2925                         info &= ~OWNER_SECURITY_INFORMATION;
2926                         goto retry;
2927                 }
2928                 /* Nothing left except GROUP, and if we removed it we
2929                  * wouldn't have anything at all.  */
2930         }
2931
2932         /* No part of the security descriptor could be set, or
2933          * WIMLIB_EXTRACT_FLAG_STRICT_ACLS is enabled and the full security
2934          * descriptor could not be set.  */
2935         if (!(info & SACL_SECURITY_INFORMATION))
2936                 ctx->partial_security_descriptors--;
2937         ctx->no_security_descriptors++;
2938
2939 out_maybe_free_desc:
2940         if (unlikely(desc_size > STACK_MAX))
2941                 FREE(desc);
2942         return status;
2943 }
2944
2945 /* Set metadata on the open file @h from the WIM inode @inode.  */
2946 static int
2947 do_apply_metadata_to_file(HANDLE h, const struct wim_inode *inode,
2948                           struct win32_apply_ctx *ctx)
2949 {
2950         FILE_BASIC_INFORMATION info;
2951         NTSTATUS status;
2952
2953         /* Set the file's object ID if present and object IDs are supported by
2954          * the filesystem.  */
2955         set_object_id(h, inode, ctx);
2956
2957         /* Set the file's security descriptor if present and we're not in
2958          * NO_ACLS mode  */
2959         if (inode_has_security_descriptor(inode) &&
2960             !(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS))
2961         {
2962                 const struct wim_security_data *sd;
2963                 const void *desc;
2964                 size_t desc_size;
2965
2966                 sd = wim_get_current_security_data(ctx->common.wim);
2967                 desc = sd->descriptors[inode->i_security_id];
2968                 desc_size = sd->sizes[inode->i_security_id];
2969
2970                 status = set_security_descriptor(h, desc, desc_size, ctx);
2971                 if (!NT_SUCCESS(status) &&
2972                     (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS))
2973                 {
2974                         winnt_error(status,
2975                                     L"Can't set security descriptor on \"%ls\"",
2976                                     current_path(ctx));
2977                         return WIMLIB_ERR_SET_SECURITY;
2978                 }
2979         }
2980
2981         /* Set attributes and timestamps  */
2982         info.CreationTime.QuadPart = inode->i_creation_time;
2983         info.LastAccessTime.QuadPart = inode->i_last_access_time;
2984         info.LastWriteTime.QuadPart = inode->i_last_write_time;
2985         info.ChangeTime.QuadPart = 0;
2986         if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES) {
2987                 info.FileAttributes = FILE_ATTRIBUTE_NORMAL;
2988         } else {
2989                 info.FileAttributes = inode->i_attributes & ~SPECIAL_ATTRIBUTES;
2990                 if (info.FileAttributes == 0)
2991                         info.FileAttributes = FILE_ATTRIBUTE_NORMAL;
2992         }
2993
2994         status = NtSetInformationFile(h, &ctx->iosb, &info, sizeof(info),
2995                                       FileBasicInformation);
2996         /* On FAT volumes we get STATUS_INVALID_PARAMETER if we try to set
2997          * attributes on the root directory.  (Apparently because FAT doesn't
2998          * actually have a place to store those attributes!)  */
2999         if (!NT_SUCCESS(status)
3000             && !(status == STATUS_INVALID_PARAMETER &&
3001                  dentry_is_root(inode_first_extraction_dentry(inode))))
3002         {
3003                 winnt_error(status, L"Can't set basic metadata on \"%ls\"",
3004                             current_path(ctx));
3005                 return WIMLIB_ERR_SET_ATTRIBUTES;
3006         }
3007
3008         return 0;
3009 }
3010
3011 static int
3012 apply_metadata_to_file(const struct wim_dentry *dentry,
3013                        struct win32_apply_ctx *ctx)
3014 {
3015         const struct wim_inode *inode = dentry->d_inode;
3016         DWORD perms;
3017         HANDLE h;
3018         NTSTATUS status;
3019         int ret;
3020
3021         perms = FILE_WRITE_ATTRIBUTES | WRITE_DAC |
3022                 WRITE_OWNER | ACCESS_SYSTEM_SECURITY;
3023
3024         build_extraction_path(dentry, ctx);
3025
3026         /* Open a handle with as many relevant permissions as possible.  */
3027         while (!NT_SUCCESS(status = do_create_file(&h, perms, NULL,
3028                                                    0, FILE_OPEN, 0, ctx)))
3029         {
3030                 if (status == STATUS_PRIVILEGE_NOT_HELD ||
3031                     status == STATUS_ACCESS_DENIED)
3032                 {
3033                         if (perms & ACCESS_SYSTEM_SECURITY) {
3034                                 perms &= ~ACCESS_SYSTEM_SECURITY;
3035                                 continue;
3036                         }
3037                         if (perms & WRITE_DAC) {
3038                                 perms &= ~WRITE_DAC;
3039                                 continue;
3040                         }
3041                         if (perms & WRITE_OWNER) {
3042                                 perms &= ~WRITE_OWNER;
3043                                 continue;
3044                         }
3045                 }
3046                 winnt_error(status, L"Can't open \"%ls\" to set metadata",
3047                             current_path(ctx));
3048                 return WIMLIB_ERR_OPEN;
3049         }
3050
3051         ret = do_apply_metadata_to_file(h, inode, ctx);
3052
3053         NtClose(h);
3054
3055         return ret;
3056 }
3057
3058 static int
3059 apply_metadata(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
3060 {
3061         const struct wim_dentry *dentry;
3062         int ret;
3063
3064         /* We go in reverse so that metadata is set on all a directory's
3065          * children before the directory itself.  This avoids any potential
3066          * problems with attributes, timestamps, or security descriptors.  */
3067         list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node)
3068         {
3069                 ret = apply_metadata_to_file(dentry, ctx);
3070                 ret = check_apply_error(dentry, ctx, ret);
3071                 if (ret)
3072                         return ret;
3073                 ret = report_file_metadata_applied(&ctx->common);
3074                 if (ret)
3075                         return ret;
3076         }
3077         return 0;
3078 }
3079
3080 /* Issue warnings about problems during the extraction for which warnings were
3081  * not already issued (due to the high number of potential warnings if we issued
3082  * them per-file).  */
3083 static void
3084 do_warnings(const struct win32_apply_ctx *ctx)
3085 {
3086         if (ctx->partial_security_descriptors == 0
3087             && ctx->no_security_descriptors == 0
3088             && ctx->num_set_short_name_failures == 0
3089         #if 0
3090             && ctx->num_remove_short_name_failures == 0
3091         #endif
3092             )
3093                 return;
3094
3095         WARNING("Extraction to \"%ls\" complete, but with one or more warnings:",
3096                 ctx->common.target);
3097         if (ctx->num_set_short_name_failures) {
3098                 WARNING("- Could not set short names on %lu files or directories",
3099                         ctx->num_set_short_name_failures);
3100         }
3101 #if 0
3102         if (ctx->num_remove_short_name_failures) {
3103                 WARNING("- Could not remove short names on %lu files or directories"
3104                         "          (This is expected on Vista and earlier)",
3105                         ctx->num_remove_short_name_failures);
3106         }
3107 #endif
3108         if (ctx->partial_security_descriptors) {
3109                 WARNING("- Could only partially set the security descriptor\n"
3110                         "            on %lu files or directories.",
3111                         ctx->partial_security_descriptors);
3112         }
3113         if (ctx->no_security_descriptors) {
3114                 WARNING("- Could not set security descriptor at all\n"
3115                         "            on %lu files or directories.",
3116                         ctx->no_security_descriptors);
3117         }
3118         if (ctx->partial_security_descriptors || ctx->no_security_descriptors) {
3119                 WARNING("To fully restore all security descriptors, run the program\n"
3120                         "          with Administrator rights.");
3121         }
3122 }
3123
3124 static u64
3125 count_dentries(const struct list_head *dentry_list)
3126 {
3127         const struct list_head *cur;
3128         u64 count = 0;
3129
3130         list_for_each(cur, dentry_list)
3131                 count++;
3132
3133         return count;
3134 }
3135
3136 /* Extract files from a WIM image to a directory on Windows  */
3137 static int
3138 win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
3139 {
3140         int ret;
3141         struct win32_apply_ctx *ctx = (struct win32_apply_ctx *)_ctx;
3142         u64 dentry_count;
3143
3144         ret = prepare_target(dentry_list, ctx);
3145         if (ret)
3146                 goto out;
3147
3148         if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) {
3149                 ret = start_wimboot_extraction(dentry_list, ctx);
3150                 if (ret)
3151                         goto out;
3152         }
3153
3154         ctx->windows_build_number = xml_get_windows_build_number(ctx->common.wim->xml_info,
3155                                                                  ctx->common.wim->current_image);
3156
3157         dentry_count = count_dentries(dentry_list);
3158
3159         ret = start_file_structure_phase(&ctx->common, dentry_count);
3160         if (ret)
3161                 goto out;
3162
3163         ret = create_directories(dentry_list, ctx);
3164         if (ret)
3165                 goto out;
3166
3167         ret = create_nondirectories(dentry_list, ctx);
3168         if (ret)
3169                 goto out;
3170
3171         ret = end_file_structure_phase(&ctx->common);
3172         if (ret)
3173                 goto out;
3174
3175         struct read_blob_callbacks cbs = {
3176                 .begin_blob     = win32_begin_extract_blob,
3177                 .continue_blob  = win32_extract_chunk,
3178                 .end_blob       = win32_end_extract_blob,
3179                 .ctx            = ctx,
3180         };
3181         ret = extract_blob_list(&ctx->common, &cbs);
3182         if (ret)
3183                 goto out;
3184
3185         ret = start_file_metadata_phase(&ctx->common, dentry_count);
3186         if (ret)
3187                 goto out;
3188
3189         ret = apply_metadata(dentry_list, ctx);
3190         if (ret)
3191                 goto out;
3192
3193         ret = end_file_metadata_phase(&ctx->common);
3194         if (ret)
3195                 goto out;
3196
3197         if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) {
3198                 ret = end_wimboot_extraction(ctx);
3199                 if (ret)
3200                         goto out;
3201         }
3202
3203         do_warnings(ctx);
3204 out:
3205         close_target_directory(ctx);
3206         if (ctx->target_ntpath.Buffer)
3207                 HeapFree(GetProcessHeap(), 0, ctx->target_ntpath.Buffer);
3208         FREE(ctx->pathbuf.Buffer);
3209         FREE(ctx->print_buffer);
3210         FREE(ctx->wimboot.wims);
3211         if (ctx->prepopulate_pats) {
3212                 FREE(ctx->prepopulate_pats->strings);
3213                 FREE(ctx->prepopulate_pats);
3214         }
3215         FREE(ctx->mem_prepopulate_pats);
3216         FREE(ctx->data_buffer);
3217         return ret;
3218 }
3219
3220 const struct apply_operations win32_apply_ops = {
3221         .name                   = "Windows",
3222         .get_supported_features = win32_get_supported_features,
3223         .extract                = win32_extract,
3224         .will_back_from_wim     = win32_will_back_from_wim,
3225         .context_size           = sizeof(struct win32_apply_ctx),
3226 };
3227
3228 #endif /* __WIN32__ */