inode.h, inode.c cleanup
[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, 2014 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/capture.h" /* for mangle_pat() and match_pattern_list()  */
33 #include "wimlib/dentry.h"
34 #include "wimlib/error.h"
35 #include "wimlib/lookup_table.h"
36 #include "wimlib/metadata.h"
37 #include "wimlib/paths.h"
38 #include "wimlib/reparse.h"
39 #include "wimlib/textfile.h"
40 #include "wimlib/xml.h"
41 #include "wimlib/wildcard.h"
42 #include "wimlib/wimboot.h"
43
44 struct win32_apply_ctx {
45
46         /* Extract flags, the pointer to the WIMStruct, etc.  */
47         struct apply_ctx common;
48
49         /* WIMBoot information, only filled in if WIMLIB_EXTRACT_FLAG_WIMBOOT
50          * was provided  */
51         struct {
52                 u64 data_source_id;
53                 struct string_set *prepopulate_pats;
54                 void *mem_prepopulate_pats;
55                 u8 wim_lookup_table_hash[SHA1_HASH_SIZE];
56                 bool wof_running;
57                 bool tried_to_load_prepopulate_list;
58         } wimboot;
59
60         /* Open handle to the target directory  */
61         HANDLE h_target;
62
63         /* NT namespace path to the target directory (buffer allocated)  */
64         UNICODE_STRING target_ntpath;
65
66         /* Temporary buffer for building paths (buffer allocated)  */
67         UNICODE_STRING pathbuf;
68
69         /* Object attributes to reuse for opening files in the target directory.
70          * (attr.ObjectName == &pathbuf) and (attr.RootDirectory == h_target).
71          */
72         OBJECT_ATTRIBUTES attr;
73
74         /* Temporary I/O status block for system calls  */
75         IO_STATUS_BLOCK iosb;
76
77         /* Allocated buffer for creating "printable" paths from our
78          * target-relative NT paths  */
79         wchar_t *print_buffer;
80
81         /* Allocated buffer for reading stream data when it cannot be extracted
82          * directly  */
83         u8 *data_buffer;
84
85         /* Pointer to the next byte in @data_buffer to fill  */
86         u8 *data_buffer_ptr;
87
88         /* Size allocated in @data_buffer  */
89         size_t data_buffer_size;
90
91         /* Current offset in the raw encrypted file being written  */
92         size_t encrypted_offset;
93
94         /* Current size of the raw encrypted file being written  */
95         size_t encrypted_size;
96
97         /* Temporary buffer for reparse data  */
98         struct reparse_buffer_disk rpbuf;
99
100         /* Temporary buffer for reparse data of "fixed" absolute symbolic links
101          * and junctions  */
102         struct reparse_buffer_disk rpfixbuf;
103
104         /* Array of open handles to filesystem streams currently being written
105          */
106         HANDLE open_handles[MAX_OPEN_STREAMS];
107
108         /* Number of handles in @open_handles currently open (filled in from the
109          * beginning of the array)  */
110         unsigned num_open_handles;
111
112         /* List of dentries, joined by @tmp_list, that need to have reparse data
113          * extracted as soon as the whole stream has been read into
114          * @data_buffer.  */
115         struct list_head reparse_dentries;
116
117         /* List of dentries, joined by @tmp_list, that need to have raw
118          * encrypted data extracted as soon as the whole stream has been read
119          * into @data_buffer.  */
120         struct list_head encrypted_dentries;
121
122         /* Number of files for which we didn't have permission to set the full
123          * security descriptor.  */
124         unsigned long partial_security_descriptors;
125
126         /* Number of files for which we didn't have permission to set any part
127          * of the security descriptor.  */
128         unsigned long no_security_descriptors;
129
130         /* Number of files for which we couldn't set the short name.  */
131         unsigned long num_set_short_name_failures;
132
133         /* Number of files for which we couldn't remove the short name.  */
134         unsigned long num_remove_short_name_failures;
135
136         /* Have we tried to enable short name support on the target volume yet?
137          */
138         bool tried_to_enable_short_names;
139 };
140
141 /* Get the drive letter from a Windows path, or return the null character if the
142  * path is relative.  */
143 static wchar_t
144 get_drive_letter(const wchar_t *path)
145 {
146         /* Skip \\?\ prefix  */
147         if (!wcsncmp(path, L"\\\\?\\", 4))
148                 path += 4;
149
150         /* Return drive letter if valid  */
151         if (((path[0] >= L'a' && path[0] <= L'z') ||
152              (path[0] >= L'A' && path[0] <= L'Z')) && path[1] == L':')
153                 return path[0];
154
155         return L'\0';
156 }
157
158 static void
159 get_vol_flags(const wchar_t *target, DWORD *vol_flags_ret,
160               bool *short_names_supported_ret)
161 {
162         wchar_t filesystem_name[MAX_PATH + 1];
163         wchar_t drive[4];
164         wchar_t *volume = NULL;
165
166         *vol_flags_ret = 0;
167         *short_names_supported_ret = false;
168
169         drive[0] = get_drive_letter(target);
170         if (drive[0]) {
171                 drive[1] = L':';
172                 drive[2] = L'\\';
173                 drive[3] = L'\0';
174                 volume = drive;
175         }
176
177         if (!GetVolumeInformation(volume, NULL, 0, NULL, NULL,
178                                   vol_flags_ret, filesystem_name,
179                                   ARRAY_LEN(filesystem_name)))
180         {
181                 DWORD err = GetLastError();
182                 set_errno_from_win32_error(err);
183                 WARNING_WITH_ERRNO("Failed to get volume information for "
184                                    "\"%ls\" (err=%"PRIu32")",
185                                    target, (u32)err);
186                 return;
187         }
188
189         if (wcsstr(filesystem_name, L"NTFS")) {
190                 /* FILE_SUPPORTS_HARD_LINKS is only supported on Windows 7 and
191                  * later.  Force it on anyway if filesystem is NTFS.  */
192                 *vol_flags_ret |= FILE_SUPPORTS_HARD_LINKS;
193
194                 /* There's no volume flag for short names, but according to the
195                  * MS documentation they are only user-settable on NTFS.  */
196                 *short_names_supported_ret = true;
197         }
198 }
199
200 static const wchar_t *
201 current_path(struct win32_apply_ctx *ctx);
202
203 static void
204 build_extraction_path(const struct wim_dentry *dentry,
205                       struct win32_apply_ctx *ctx);
206
207 static int
208 report_dentry_apply_error(const struct wim_dentry *dentry,
209                           struct win32_apply_ctx *ctx, int ret)
210 {
211         build_extraction_path(dentry, ctx);
212         return report_apply_error(&ctx->common, ret, current_path(ctx));
213 }
214
215 static inline int
216 check_apply_error(const struct wim_dentry *dentry,
217                   struct win32_apply_ctx *ctx, int ret)
218 {
219         if (unlikely(ret))
220                 ret = report_dentry_apply_error(dentry, ctx, ret);
221         return ret;
222 }
223
224 static int
225 win32_get_supported_features(const wchar_t *target,
226                              struct wim_features *supported_features)
227 {
228         DWORD vol_flags;
229         bool short_names_supported;
230
231         /* Query the features of the target volume.  */
232
233         get_vol_flags(target, &vol_flags, &short_names_supported);
234
235         supported_features->archive_files = 1;
236         supported_features->hidden_files = 1;
237         supported_features->system_files = 1;
238
239         if (vol_flags & FILE_FILE_COMPRESSION)
240                 supported_features->compressed_files = 1;
241
242         if (vol_flags & FILE_SUPPORTS_ENCRYPTION) {
243                 supported_features->encrypted_files = 1;
244                 supported_features->encrypted_directories = 1;
245         }
246
247         supported_features->not_context_indexed_files = 1;
248
249         /* Don't do anything with FILE_SUPPORTS_SPARSE_FILES.  */
250
251         if (vol_flags & FILE_NAMED_STREAMS)
252                 supported_features->named_data_streams = 1;
253
254         if (vol_flags & FILE_SUPPORTS_HARD_LINKS)
255                 supported_features->hard_links = 1;
256
257         if (vol_flags & FILE_SUPPORTS_REPARSE_POINTS)
258                 supported_features->reparse_points = 1;
259
260         if (vol_flags & FILE_PERSISTENT_ACLS)
261                 supported_features->security_descriptors = 1;
262
263         if (short_names_supported)
264                 supported_features->short_names = 1;
265
266         supported_features->timestamps = 1;
267
268         /* Note: Windows does not support case sensitive filenames!  At least
269          * not without changing the registry and rebooting...  */
270
271         return 0;
272 }
273
274 /* Load the patterns from [PrepopulateList] of WimBootCompress.ini in the WIM
275  * image being extracted.  */
276 static int
277 load_prepopulate_pats(struct win32_apply_ctx *ctx)
278 {
279         const wchar_t *path = L"\\Windows\\System32\\WimBootCompress.ini";
280         struct wim_dentry *dentry;
281         struct wim_lookup_table_entry *lte;
282         int ret;
283         void *buf;
284         struct string_set *s;
285         void *mem;
286         struct text_file_section sec;
287
288         ctx->wimboot.tried_to_load_prepopulate_list = true;
289
290         dentry = get_dentry(ctx->common.wim, path, WIMLIB_CASE_INSENSITIVE);
291         if (!dentry ||
292             (dentry->d_inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
293                                               FILE_ATTRIBUTE_REPARSE_POINT |
294                                               FILE_ATTRIBUTE_ENCRYPTED)) ||
295             !(lte = inode_unnamed_lte(dentry->d_inode, ctx->common.wim->lookup_table)))
296         {
297                 WARNING("%ls does not exist in WIM image!", path);
298                 return WIMLIB_ERR_PATH_DOES_NOT_EXIST;
299         }
300
301         ret = read_full_stream_into_alloc_buf(lte, &buf);
302         if (ret)
303                 return ret;
304
305         s = CALLOC(1, sizeof(struct string_set));
306         if (!s) {
307                 FREE(buf);
308                 return WIMLIB_ERR_NOMEM;
309         }
310
311         sec.name = T("PrepopulateList");
312         sec.strings = s;
313
314         ret = do_load_text_file(path, buf, lte->size, &mem, &sec, 1,
315                                 LOAD_TEXT_FILE_REMOVE_QUOTES |
316                                         LOAD_TEXT_FILE_NO_WARNINGS,
317                                 mangle_pat);
318         BUILD_BUG_ON(OS_PREFERRED_PATH_SEPARATOR != WIM_PATH_SEPARATOR);
319         FREE(buf);
320         if (ret) {
321                 FREE(s);
322                 return ret;
323         }
324         ctx->wimboot.prepopulate_pats = s;
325         ctx->wimboot.mem_prepopulate_pats = mem;
326         return 0;
327 }
328
329 /* Returns %true if the specified absolute path to a file in the WIM image
330  * matches a pattern in [PrepopulateList] of WimBootCompress.ini.  Otherwise
331  * returns %false.  */
332 static bool
333 in_prepopulate_list(const wchar_t *path, size_t path_nchars,
334                     const struct win32_apply_ctx *ctx)
335 {
336         const struct string_set *pats = ctx->wimboot.prepopulate_pats;
337
338         if (!pats || !pats->num_strings)
339                 return false;
340
341         return match_pattern_list(path, path_nchars, pats);
342 }
343
344 /* Returns %true if the specified absolute path to a file in the WIM image can
345  * be subject to external backing when extracted.  Otherwise returns %false.  */
346 static bool
347 can_externally_back_path(const wchar_t *path, size_t path_nchars,
348                          const struct win32_apply_ctx *ctx)
349 {
350         if (in_prepopulate_list(path, path_nchars, ctx))
351                 return false;
352
353         /* Since we attempt to modify the SYSTEM registry after it's extracted
354          * (see end_wimboot_extraction()), it can't be extracted as externally
355          * backed.  This extends to associated files such as SYSTEM.LOG that
356          * also must be writable in order to write to the registry.  Normally,
357          * SYSTEM is in [PrepopulateList], and the SYSTEM.* files match patterns
358          * in [ExclusionList] and therefore are not captured in the WIM at all.
359          * However, a WIM that wasn't specifically captured in "WIMBoot mode"
360          * may contain SYSTEM.* files.  So to make things "just work", hard-code
361          * the pattern.  */
362         if (match_path(path, path_nchars, L"\\Windows\\System32\\config\\SYSTEM*",
363                        OS_PREFERRED_PATH_SEPARATOR, false))
364                 return false;
365
366         return true;
367 }
368
369 #define WIM_BACKING_NOT_ENABLED         -1
370 #define WIM_BACKING_NOT_POSSIBLE        -2
371 #define WIM_BACKING_EXCLUDED            -3
372
373 static int
374 will_externally_back_inode(struct wim_inode *inode, struct win32_apply_ctx *ctx,
375                            const struct wim_dentry **excluded_dentry_ret)
376 {
377         struct list_head *next;
378         struct wim_dentry *dentry;
379         struct wim_lookup_table_entry *stream;
380         int ret;
381
382         if (inode->i_can_externally_back)
383                 return 0;
384
385         /* This may do redundant checks because the cached value
386          * i_can_externally_back is 2-state (as opposed to 3-state:
387          * unknown/no/yes).  But most files can be externally backed, so this
388          * way is fine.  */
389
390         if (inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
391                                    FILE_ATTRIBUTE_REPARSE_POINT |
392                                    FILE_ATTRIBUTE_ENCRYPTED))
393                 return WIM_BACKING_NOT_POSSIBLE;
394
395         stream = inode_unnamed_lte_resolved(inode);
396
397         if (!stream ||
398             stream->resource_location != RESOURCE_IN_WIM ||
399             stream->rspec->wim != ctx->common.wim ||
400             stream->size != stream->rspec->uncompressed_size)
401                 return WIM_BACKING_NOT_POSSIBLE;
402
403         /*
404          * We need to check the patterns in [PrepopulateList] against every name
405          * of the inode, in case any of them match.
406          */
407         next = inode->i_extraction_aliases.next;
408         do {
409                 dentry = list_entry(next, struct wim_dentry,
410                                     d_extraction_alias_node);
411
412                 ret = calculate_dentry_full_path(dentry);
413                 if (ret)
414                         return ret;
415
416                 if (!can_externally_back_path(dentry->_full_path,
417                                               wcslen(dentry->_full_path), ctx))
418                 {
419                         if (excluded_dentry_ret)
420                                 *excluded_dentry_ret = dentry;
421                         return WIM_BACKING_EXCLUDED;
422                 }
423                 next = next->next;
424         } while (next != &inode->i_extraction_aliases);
425
426         inode->i_can_externally_back = 1;
427         return 0;
428 }
429
430 /*
431  * Determines if the unnamed data stream of a file will be created as an
432  * external backing, as opposed to a standard extraction.
433  */
434 static int
435 win32_will_externally_back(struct wim_dentry *dentry, struct apply_ctx *_ctx)
436 {
437         struct win32_apply_ctx *ctx = (struct win32_apply_ctx *)_ctx;
438
439         if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT))
440                 return WIM_BACKING_NOT_ENABLED;
441
442         if (!ctx->wimboot.tried_to_load_prepopulate_list)
443                 if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
444                         return WIMLIB_ERR_NOMEM;
445
446         return will_externally_back_inode(dentry->d_inode, ctx, NULL);
447 }
448
449 static int
450 set_external_backing(HANDLE h, struct wim_inode *inode, struct win32_apply_ctx *ctx)
451 {
452         int ret;
453         const struct wim_dentry *excluded_dentry;
454
455         ret = will_externally_back_inode(inode, ctx, &excluded_dentry);
456         if (ret > 0) /* Error.  */
457                 return ret;
458
459         if (ret < 0 && ret != WIM_BACKING_EXCLUDED)
460                 return 0; /* Not externally backing, other than due to exclusion.  */
461
462         if (unlikely(ret == WIM_BACKING_EXCLUDED)) {
463                 /* Not externally backing due to exclusion.  */
464                 union wimlib_progress_info info;
465
466                 build_extraction_path(excluded_dentry, ctx);
467
468                 info.wimboot_exclude.path_in_wim = excluded_dentry->_full_path;
469                 info.wimboot_exclude.extraction_path = current_path(ctx);
470
471                 return call_progress(ctx->common.progfunc,
472                                      WIMLIB_PROGRESS_MSG_WIMBOOT_EXCLUDE,
473                                      &info, ctx->common.progctx);
474         } else {
475                 /* Externally backing.  */
476                 if (unlikely(!wimboot_set_pointer(h,
477                                                   inode_unnamed_lte_resolved(inode),
478                                                   ctx->wimboot.data_source_id,
479                                                   ctx->wimboot.wim_lookup_table_hash,
480                                                   ctx->wimboot.wof_running)))
481                 {
482                         const DWORD err = GetLastError();
483
484                         build_extraction_path(inode_first_extraction_dentry(inode), ctx);
485                         set_errno_from_win32_error(err);
486                         ERROR_WITH_ERRNO("\"%ls\": Couldn't set WIMBoot "
487                                          "pointer data (err=%"PRIu32")",
488                                          current_path(ctx), (u32)err);
489                         return WIMLIB_ERR_WIMBOOT;
490                 }
491                 return 0;
492         }
493 }
494
495 /* Calculates the SHA-1 message digest of the WIM's lookup table.  */
496 static int
497 hash_lookup_table(WIMStruct *wim, u8 hash[SHA1_HASH_SIZE])
498 {
499         return wim_reshdr_to_hash(&wim->hdr.lookup_table_reshdr, wim, hash);
500 }
501
502 /* Prepare for doing a "WIMBoot" extraction by loading patterns from
503  * [PrepopulateList] of WimBootCompress.ini and allocating a WOF data source ID
504  * on the target volume.  */
505 static int
506 start_wimboot_extraction(struct win32_apply_ctx *ctx)
507 {
508         int ret;
509         WIMStruct *wim = ctx->common.wim;
510
511         if (!ctx->wimboot.tried_to_load_prepopulate_list)
512                 if (load_prepopulate_pats(ctx) == WIMLIB_ERR_NOMEM)
513                         return WIMLIB_ERR_NOMEM;
514
515         if (!wim_info_get_wimboot(wim->wim_info, wim->current_image))
516                 WARNING("Image is not marked as WIMBoot compatible!");
517
518         ret = hash_lookup_table(ctx->common.wim,
519                                 ctx->wimboot.wim_lookup_table_hash);
520         if (ret)
521                 return ret;
522
523         return wimboot_alloc_data_source_id(wim->filename,
524                                             wim->hdr.guid,
525                                             wim->current_image,
526                                             ctx->common.target,
527                                             &ctx->wimboot.data_source_id,
528                                             &ctx->wimboot.wof_running);
529 }
530
531 static void
532 build_win32_extraction_path(const struct wim_dentry *dentry,
533                             struct win32_apply_ctx *ctx);
534
535 /* Sets WimBoot=1 in the extracted SYSTEM registry hive.
536  *
537  * WIMGAPI does this, and it's possible that it's important.
538  * But I don't know exactly what this value means to Windows.  */
539 static int
540 end_wimboot_extraction(struct win32_apply_ctx *ctx)
541 {
542         struct wim_dentry *dentry;
543         wchar_t subkeyname[32];
544         LONG res;
545         LONG res2;
546         HKEY key;
547         DWORD value;
548
549         dentry = get_dentry(ctx->common.wim, L"\\Windows\\System32\\config\\SYSTEM",
550                             WIMLIB_CASE_INSENSITIVE);
551
552         if (!dentry || !will_extract_dentry(dentry))
553                 goto out;
554
555         if (!will_extract_dentry(wim_get_current_root_dentry(ctx->common.wim)))
556                 goto out;
557
558         /* Not bothering to use the native routines (e.g. NtLoadKey()) for this.
559          * If this doesn't work, you probably also have many other problems.  */
560
561         build_win32_extraction_path(dentry, ctx);
562
563         randomize_char_array_with_alnum(subkeyname, 20);
564         subkeyname[20] = L'\0';
565
566         res = RegLoadKey(HKEY_LOCAL_MACHINE, subkeyname, ctx->pathbuf.Buffer);
567         if (res)
568                 goto out_check_res;
569
570         wcscpy(&subkeyname[20], L"\\Setup");
571
572         res = RegCreateKeyEx(HKEY_LOCAL_MACHINE, subkeyname, 0, NULL,
573                              REG_OPTION_BACKUP_RESTORE, 0, NULL, &key, NULL);
574         if (res)
575                 goto out_unload_key;
576
577         value = 1;
578
579         res = RegSetValueEx(key, L"WimBoot", 0, REG_DWORD,
580                             (const BYTE *)&value, sizeof(DWORD));
581         if (res)
582                 goto out_close_key;
583
584         res = RegFlushKey(key);
585
586 out_close_key:
587         res2 = RegCloseKey(key);
588         if (!res)
589                 res = res2;
590 out_unload_key:
591         subkeyname[20] = L'\0';
592         RegUnLoadKey(HKEY_LOCAL_MACHINE, subkeyname);
593 out_check_res:
594         if (res) {
595                 /* Warning only.  */
596                 set_errno_from_win32_error(res);
597                 WARNING_WITH_ERRNO("Failed to set \\Setup: dword \"WimBoot\"=1 value "
598                                    "in registry hive \"%ls\" (err=%"PRIu32")",
599                                    ctx->pathbuf.Buffer, (u32)res);
600         }
601 out:
602         return 0;
603 }
604
605 /* Returns the number of wide characters needed to represent the path to the
606  * specified @dentry, relative to the target directory, when extracted.
607  *
608  * Does not include null terminator (not needed for NtCreateFile).  */
609 static size_t
610 dentry_extraction_path_length(const struct wim_dentry *dentry)
611 {
612         size_t len = 0;
613         const struct wim_dentry *d;
614
615         d = dentry;
616         do {
617                 len += d->d_extraction_name_nchars + 1;
618                 d = d->d_parent;
619         } while (!dentry_is_root(d) && will_extract_dentry(d));
620
621         return --len;  /* No leading slash  */
622 }
623
624 /* Returns the length of the longest string that might need to be appended to
625  * the path to an alias of an inode to open or create a named data stream.
626  *
627  * If the inode has no named data streams, this will be 0.  Otherwise, this will
628  * be 1 plus the length of the longest-named data stream, since the data stream
629  * name must be separated from the path by the ':' character.  */
630 static size_t
631 inode_longest_named_data_stream_spec(const struct wim_inode *inode)
632 {
633         size_t max = 0;
634         for (u16 i = 0; i < inode->i_num_ads; i++) {
635                 size_t len = inode->i_ads_entries[i].stream_name_nbytes;
636                 if (len > max)
637                         max = len;
638         }
639         if (max)
640                 max = 1 + (max / sizeof(wchar_t));
641         return max;
642 }
643
644 /* Find the length, in wide characters, of the longest path needed for
645  * extraction of any file in @dentry_list relative to the target directory.
646  *
647  * Accounts for named data streams, but does not include null terminator (not
648  * needed for NtCreateFile).  */
649 static size_t
650 compute_path_max(struct list_head *dentry_list)
651 {
652         size_t max = 0;
653         const struct wim_dentry *dentry;
654
655         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
656                 size_t len;
657
658                 len = dentry_extraction_path_length(dentry);
659
660                 /* Account for named data streams  */
661                 len += inode_longest_named_data_stream_spec(dentry->d_inode);
662
663                 if (len > max)
664                         max = len;
665         }
666
667         return max;
668 }
669
670 /* Build the path at which to extract the @dentry, relative to the target
671  * directory.
672  *
673  * The path is saved in ctx->pathbuf.  */
674 static void
675 build_extraction_path(const struct wim_dentry *dentry,
676                       struct win32_apply_ctx *ctx)
677 {
678         size_t len;
679         wchar_t *p;
680         const struct wim_dentry *d;
681
682         len = dentry_extraction_path_length(dentry);
683
684         ctx->pathbuf.Length = len * sizeof(wchar_t);
685         p = ctx->pathbuf.Buffer + len;
686         for (d = dentry;
687              !dentry_is_root(d->d_parent) && will_extract_dentry(d->d_parent);
688              d = d->d_parent)
689         {
690                 p -= d->d_extraction_name_nchars;
691                 wmemcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
692                 *--p = '\\';
693         }
694         /* No leading slash  */
695         p -= d->d_extraction_name_nchars;
696         wmemcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
697 }
698
699 /* Build the path at which to extract the @dentry, relative to the target
700  * directory, adding the suffix for a named data stream.
701  *
702  * The path is saved in ctx->pathbuf.  */
703 static void
704 build_extraction_path_with_ads(const struct wim_dentry *dentry,
705                                struct win32_apply_ctx *ctx,
706                                const wchar_t *stream_name,
707                                size_t stream_name_nchars)
708 {
709         wchar_t *p;
710
711         build_extraction_path(dentry, ctx);
712
713         /* Add :NAME for named data stream  */
714         p = ctx->pathbuf.Buffer + (ctx->pathbuf.Length / sizeof(wchar_t));
715         *p++ = L':';
716         wmemcpy(p, stream_name, stream_name_nchars);
717         ctx->pathbuf.Length += (1 + stream_name_nchars) * sizeof(wchar_t);
718 }
719
720 /* Build the Win32 namespace path to the specified @dentry when extracted.
721  *
722  * The path is saved in ctx->pathbuf and will be null terminated.
723  *
724  * XXX: We could get rid of this if it wasn't needed for the file encryption
725  * APIs, and the registry manipulation in WIMBoot mode.  */
726 static void
727 build_win32_extraction_path(const struct wim_dentry *dentry,
728                             struct win32_apply_ctx *ctx)
729 {
730         build_extraction_path(dentry, ctx);
731
732         /* Prepend target_ntpath to our relative path, then change \??\ into \\?\  */
733
734         memmove(ctx->pathbuf.Buffer +
735                         (ctx->target_ntpath.Length / sizeof(wchar_t)) + 1,
736                 ctx->pathbuf.Buffer, ctx->pathbuf.Length);
737         memcpy(ctx->pathbuf.Buffer, ctx->target_ntpath.Buffer,
738                 ctx->target_ntpath.Length);
739         ctx->pathbuf.Buffer[ctx->target_ntpath.Length / sizeof(wchar_t)] = L'\\';
740         ctx->pathbuf.Length += ctx->target_ntpath.Length + sizeof(wchar_t);
741         ctx->pathbuf.Buffer[ctx->pathbuf.Length / sizeof(wchar_t)] = L'\0';
742
743         wimlib_assert(ctx->pathbuf.Length >= 4 * sizeof(wchar_t) &&
744                       !wmemcmp(ctx->pathbuf.Buffer, L"\\??\\", 4));
745
746         ctx->pathbuf.Buffer[1] = L'\\';
747
748 }
749
750 /* Returns a "printable" representation of the last relative NT path that was
751  * constructed with build_extraction_path() or build_extraction_path_with_ads().
752  *
753  * This will be overwritten by the next call to this function.  */
754 static const wchar_t *
755 current_path(struct win32_apply_ctx *ctx)
756 {
757         wchar_t *p = ctx->print_buffer;
758
759         p = wmempcpy(p, ctx->common.target, ctx->common.target_nchars);
760         *p++ = L'\\';
761         p = wmempcpy(p, ctx->pathbuf.Buffer, ctx->pathbuf.Length / sizeof(wchar_t));
762         *p = L'\0';
763         return ctx->print_buffer;
764 }
765
766 /*
767  * Ensures the target directory exists and opens a handle to it, in preparation
768  * of using paths relative to it.
769  */
770 static int
771 prepare_target(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
772 {
773         int ret;
774         NTSTATUS status;
775         size_t path_max;
776
777         /* Open handle to the target directory (possibly creating it).  */
778
779         ret = win32_path_to_nt_path(ctx->common.target, &ctx->target_ntpath);
780         if (ret)
781                 return ret;
782
783         ctx->attr.Length = sizeof(ctx->attr);
784         ctx->attr.ObjectName = &ctx->target_ntpath;
785
786         status = (*func_NtCreateFile)(&ctx->h_target,
787                                       FILE_TRAVERSE,
788                                       &ctx->attr,
789                                       &ctx->iosb,
790                                       NULL,
791                                       0,
792                                       FILE_SHARE_VALID_FLAGS,
793                                       FILE_OPEN_IF,
794                                       FILE_DIRECTORY_FILE |
795                                               FILE_OPEN_REPARSE_POINT |
796                                               FILE_OPEN_FOR_BACKUP_INTENT,
797                                       NULL,
798                                       0);
799
800         if (!NT_SUCCESS(status)) {
801                 set_errno_from_nt_status(status);
802                 ERROR_WITH_ERRNO("Can't open or create directory \"%ls\" "
803                                  "(status=0x%08"PRIx32")",
804                                  ctx->common.target, (u32)status);
805                 return WIMLIB_ERR_OPENDIR;
806         }
807
808         path_max = compute_path_max(dentry_list);
809
810         /* Add some extra for building Win32 paths for the file encryption APIs,
811          * and ensure we have at least enough to potentially use a 8.3 name for
812          * the last component.  */
813         path_max += max(2 + (ctx->target_ntpath.Length / sizeof(wchar_t)),
814                         8 + 1 + 3);
815
816         ctx->pathbuf.MaximumLength = path_max * sizeof(wchar_t);
817         ctx->pathbuf.Buffer = MALLOC(ctx->pathbuf.MaximumLength);
818         if (!ctx->pathbuf.Buffer)
819                 return WIMLIB_ERR_NOMEM;
820
821         ctx->attr.RootDirectory = ctx->h_target;
822         ctx->attr.ObjectName = &ctx->pathbuf;
823
824         ctx->print_buffer = MALLOC((ctx->common.target_nchars + 1 + path_max + 1) *
825                                    sizeof(wchar_t));
826         if (!ctx->print_buffer)
827                 return WIMLIB_ERR_NOMEM;
828
829         return 0;
830 }
831
832 /* When creating an inode that will have a short (DOS) name, we create it using
833  * the long name associated with the short name.  This ensures that the short
834  * name gets associated with the correct long name.  */
835 static struct wim_dentry *
836 first_extraction_alias(const struct wim_inode *inode)
837 {
838         struct list_head *next = inode->i_extraction_aliases.next;
839         struct wim_dentry *dentry;
840
841         do {
842                 dentry = list_entry(next, struct wim_dentry,
843                                     d_extraction_alias_node);
844                 if (dentry_has_short_name(dentry))
845                         break;
846                 next = next->next;
847         } while (next != &inode->i_extraction_aliases);
848         return dentry;
849 }
850
851 /*
852  * Set or clear FILE_ATTRIBUTE_COMPRESSED if the inherited value is different
853  * from the desired value.
854  *
855  * Note that you can NOT override the inherited value of
856  * FILE_ATTRIBUTE_COMPRESSED directly with NtCreateFile().
857  */
858 static int
859 adjust_compression_attribute(HANDLE h, const struct wim_dentry *dentry,
860                              struct win32_apply_ctx *ctx)
861 {
862         const bool compressed = (dentry->d_inode->i_attributes &
863                                  FILE_ATTRIBUTE_COMPRESSED);
864
865         if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)
866                 return 0;
867
868         if (!ctx->common.supported_features.compressed_files)
869                 return 0;
870
871         FILE_BASIC_INFORMATION info;
872         NTSTATUS status;
873         USHORT compression_state;
874
875         /* Get current attributes  */
876         status = (*func_NtQueryInformationFile)(h, &ctx->iosb,
877                                                 &info, sizeof(info),
878                                                 FileBasicInformation);
879         if (NT_SUCCESS(status) &&
880             compressed == !!(info.FileAttributes & FILE_ATTRIBUTE_COMPRESSED))
881         {
882                 /* Nothing needs to be done.  */
883                 return 0;
884         }
885
886         /* Set the new compression state  */
887
888         if (compressed)
889                 compression_state = COMPRESSION_FORMAT_DEFAULT;
890         else
891                 compression_state = COMPRESSION_FORMAT_NONE;
892
893         status = (*func_NtFsControlFile)(h,
894                                          NULL,
895                                          NULL,
896                                          NULL,
897                                          &ctx->iosb,
898                                          FSCTL_SET_COMPRESSION,
899                                          &compression_state,
900                                          sizeof(USHORT),
901                                          NULL,
902                                          0);
903         if (NT_SUCCESS(status))
904                 return 0;
905
906         set_errno_from_nt_status(status);
907         ERROR_WITH_ERRNO("Can't %s compression attribute on \"%ls\" "
908                          "(status=0x%08"PRIx32")",
909                          (compressed ? "set" : "clear"),
910                          current_path(ctx), status);
911         return WIMLIB_ERR_SET_ATTRIBUTES;
912 }
913
914 /*
915  * Clear FILE_ATTRIBUTE_ENCRYPTED if the file or directory is not supposed to be
916  * encrypted.
917  *
918  * You can provide FILE_ATTRIBUTE_ENCRYPTED to NtCreateFile() to set it on the
919  * created file.  However, the file or directory will otherwise default to the
920  * encryption state of the parent directory.  This function works around this
921  * limitation by using DecryptFile() to remove FILE_ATTRIBUTE_ENCRYPTED on files
922  * (and directories) that are not supposed to have it set.
923  *
924  * Regardless of whether it succeeds or fails, this function may close the
925  * handle to the file.  If it does, it sets it to NULL.
926  */
927 static int
928 maybe_clear_encryption_attribute(HANDLE *h_ptr, const struct wim_dentry *dentry,
929                                  struct win32_apply_ctx *ctx)
930 {
931         if (dentry->d_inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)
932                 return 0;
933
934         if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)
935                 return 0;
936
937         if (!ctx->common.supported_features.encrypted_files)
938                 return 0;
939
940         FILE_BASIC_INFORMATION info;
941         NTSTATUS status;
942         BOOL bret;
943
944         /* Get current attributes  */
945         status = (*func_NtQueryInformationFile)(*h_ptr, &ctx->iosb,
946                                                 &info, sizeof(info),
947                                                 FileBasicInformation);
948         if (NT_SUCCESS(status) &&
949             !(info.FileAttributes & FILE_ATTRIBUTE_ENCRYPTED))
950         {
951                 /* Nothing needs to be done.  */
952                 return 0;
953         }
954
955         /* Set the new encryption state  */
956
957         /* Due to Windows' crappy file encryption APIs, we need to close the
958          * handle to the file so we don't get ERROR_SHARING_VIOLATION.  We also
959          * hack together a Win32 path, although we will use the \\?\ prefix so
960          * it will actually be a NT path in disguise...  */
961         (*func_NtClose)(*h_ptr);
962         *h_ptr = NULL;
963
964         build_win32_extraction_path(dentry, ctx);
965
966         bret = DecryptFile(ctx->pathbuf.Buffer, 0);
967
968         /* Restore the NT namespace path  */
969         build_extraction_path(dentry, ctx);
970
971         if (!bret) {
972                 DWORD err = GetLastError();
973                 set_errno_from_win32_error(err);
974                 ERROR_WITH_ERRNO("Can't decrypt file \"%ls\" (err=%"PRIu32")",
975                                   current_path(ctx), (u32)err);
976                 return WIMLIB_ERR_SET_ATTRIBUTES;
977         }
978         return 0;
979 }
980
981 /* Try to enable short name support on the target volume.  If successful, return
982  * true.  If unsuccessful, issue a warning and return false.  */
983 static bool
984 try_to_enable_short_names(const wchar_t *volume)
985 {
986         HANDLE h;
987         FILE_FS_PERSISTENT_VOLUME_INFORMATION info;
988         BOOL bret;
989         DWORD bytesReturned;
990
991         h = CreateFile(volume, GENERIC_WRITE,
992                        FILE_SHARE_VALID_FLAGS, NULL, OPEN_EXISTING,
993                        FILE_FLAG_BACKUP_SEMANTICS, NULL);
994         if (h == INVALID_HANDLE_VALUE)
995                 goto fail;
996
997         info.VolumeFlags = 0;
998         info.FlagMask = PERSISTENT_VOLUME_STATE_SHORT_NAME_CREATION_DISABLED;
999         info.Version = 1;
1000         info.Reserved = 0;
1001
1002         bret = DeviceIoControl(h, FSCTL_SET_PERSISTENT_VOLUME_STATE,
1003                                &info, sizeof(info), NULL, 0,
1004                                &bytesReturned, NULL);
1005
1006         CloseHandle(h);
1007
1008         if (!bret)
1009                 goto fail;
1010         return true;
1011
1012 fail:
1013         WARNING("Failed to enable short name support on %ls "
1014                 "(err=%"PRIu32")", volume + 4, (u32)GetLastError());
1015         return false;
1016 }
1017
1018 static NTSTATUS
1019 remove_conflicting_short_name(const struct wim_dentry *dentry, struct win32_apply_ctx *ctx)
1020 {
1021         wchar_t *name;
1022         wchar_t *end;
1023         NTSTATUS status;
1024         HANDLE h;
1025         size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) +
1026                          (13 * sizeof(wchar_t));
1027         u8 buf[bufsize] _aligned_attribute(8);
1028         bool retried = false;
1029         FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf;
1030
1031         memset(buf, 0, bufsize);
1032
1033         /* Build the path with the short name.  */
1034         name = &ctx->pathbuf.Buffer[ctx->pathbuf.Length / sizeof(wchar_t)];
1035         while (name != ctx->pathbuf.Buffer && *(name - 1) != L'\\')
1036                 name--;
1037         end = mempcpy(name, dentry->short_name, dentry->short_name_nbytes);
1038         ctx->pathbuf.Length = ((u8 *)end - (u8 *)ctx->pathbuf.Buffer);
1039
1040         /* Open the conflicting file (by short name).  */
1041         status = (*func_NtOpenFile)(&h, GENERIC_WRITE | DELETE,
1042                                     &ctx->attr, &ctx->iosb,
1043                                     FILE_SHARE_VALID_FLAGS,
1044                                     FILE_OPEN_REPARSE_POINT | FILE_OPEN_FOR_BACKUP_INTENT);
1045         if (!NT_SUCCESS(status)) {
1046                 WARNING("Can't open \"%ls\" (status=0x%08"PRIx32")",
1047                         current_path(ctx), (u32)status);
1048                 goto out;
1049         }
1050
1051 #if 0
1052         WARNING("Overriding conflicting short name; path=\"%ls\"",
1053                 current_path(ctx));
1054 #endif
1055
1056         /* Try to remove the short name on the conflicting file.  */
1057
1058 retry:
1059         status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize,
1060                                               FileShortNameInformation);
1061
1062         if (status == STATUS_INVALID_PARAMETER && !retried) {
1063
1064                 /* Microsoft forgot to make it possible to remove short names
1065                  * until Windows 7.  Oops.  Use a random short name instead.  */
1066
1067                 info->FileNameLength = 12 * sizeof(wchar_t);
1068                 for (int i = 0; i < 8; i++)
1069                         info->FileName[i] = 'A' + (rand() % 26);
1070                 info->FileName[8] = L'.';
1071                 info->FileName[9] = L'W';
1072                 info->FileName[10] = L'L';
1073                 info->FileName[11] = L'B';
1074                 info->FileName[12] = L'\0';
1075                 retried = true;
1076                 goto retry;
1077         }
1078         (*func_NtClose)(h);
1079 out:
1080         build_extraction_path(dentry, ctx);
1081         return status;
1082 }
1083
1084 /* Set the short name on the open file @h which has been created at the location
1085  * indicated by @dentry.
1086  *
1087  * Note that this may add, change, or remove the short name.
1088  *
1089  * @h must be opened with DELETE access.
1090  *
1091  * Returns 0 or WIMLIB_ERR_SET_SHORT_NAME.  The latter only happens in
1092  * STRICT_SHORT_NAMES mode.
1093  */
1094 static int
1095 set_short_name(HANDLE h, const struct wim_dentry *dentry,
1096                struct win32_apply_ctx *ctx)
1097 {
1098
1099         if (!ctx->common.supported_features.short_names)
1100                 return 0;
1101
1102         /*
1103          * Note: The size of the FILE_NAME_INFORMATION buffer must be such that
1104          * FileName contains at least 2 wide characters (4 bytes).  Otherwise,
1105          * NtSetInformationFile() will return STATUS_INFO_LENGTH_MISMATCH.  This
1106          * is despite the fact that FileNameLength can validly be 0 or 2 bytes,
1107          * with the former case being removing the existing short name if
1108          * present, rather than setting one.
1109          *
1110          * The null terminator is seemingly optional, but to be safe we include
1111          * space for it and zero all unused space.
1112          */
1113
1114         size_t bufsize = offsetof(FILE_NAME_INFORMATION, FileName) +
1115                          max(dentry->short_name_nbytes, sizeof(wchar_t)) +
1116                          sizeof(wchar_t);
1117         u8 buf[bufsize] _aligned_attribute(8);
1118         FILE_NAME_INFORMATION *info = (FILE_NAME_INFORMATION *)buf;
1119         NTSTATUS status;
1120         bool tried_to_remove_existing = false;
1121
1122         memset(buf, 0, bufsize);
1123
1124         info->FileNameLength = dentry->short_name_nbytes;
1125         memcpy(info->FileName, dentry->short_name, dentry->short_name_nbytes);
1126
1127 retry:
1128         status = (*func_NtSetInformationFile)(h, &ctx->iosb, info, bufsize,
1129                                               FileShortNameInformation);
1130         if (NT_SUCCESS(status))
1131                 return 0;
1132
1133         if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) {
1134                 if (dentry->short_name_nbytes == 0)
1135                         return 0;
1136                 if (!ctx->tried_to_enable_short_names) {
1137                         wchar_t volume[7];
1138                         int ret;
1139
1140                         ctx->tried_to_enable_short_names = true;
1141
1142                         ret = win32_get_drive_path(ctx->common.target,
1143                                                    volume);
1144                         if (ret)
1145                                 return ret;
1146                         if (try_to_enable_short_names(volume))
1147                                 goto retry;
1148                 }
1149         }
1150
1151         /*
1152          * Short names can conflict in several cases:
1153          *
1154          * - a file being extracted has a short name conflicting with an
1155          *   existing file
1156          *
1157          * - a file being extracted has a short name conflicting with another
1158          *   file being extracted (possible, but shouldn't happen)
1159          *
1160          * - a file being extracted has a short name that conflicts with the
1161          *   automatically generated short name of a file we previously
1162          *   extracted, but failed to set the short name for.  Sounds unlikely,
1163          *   but this actually does happen fairly often on versions of Windows
1164          *   prior to Windows 7 because they do not support removing short names
1165          *   from files.
1166          */
1167         if (unlikely(status == STATUS_OBJECT_NAME_COLLISION) &&
1168             dentry->short_name_nbytes && !tried_to_remove_existing)
1169         {
1170                 tried_to_remove_existing = true;
1171                 status = remove_conflicting_short_name(dentry, ctx);
1172                 if (NT_SUCCESS(status))
1173                         goto retry;
1174         }
1175
1176         /* By default, failure to set short names is not an error (since short
1177          * names aren't too important anymore...).  */
1178         if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES)) {
1179                 if (dentry->short_name_nbytes)
1180                         ctx->num_set_short_name_failures++;
1181                 else
1182                         ctx->num_remove_short_name_failures++;
1183                 return 0;
1184         }
1185
1186         if (status == STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME) {
1187                 ERROR("Can't set short name when short "
1188                       "names are not enabled on the volume!");
1189         } else {
1190                 ERROR("Can't set short name on \"%ls\" (status=0x%08"PRIx32")",
1191                       current_path(ctx), (u32)status);
1192         }
1193         return WIMLIB_ERR_SET_SHORT_NAME;
1194 }
1195
1196 /*
1197  * A wrapper around NtCreateFile() to make it slightly more usable...
1198  * This uses the path currently constructed in ctx->pathbuf.
1199  *
1200  * Also, we always specify FILE_OPEN_FOR_BACKUP_INTENT and
1201  * FILE_OPEN_REPARSE_POINT.
1202  */
1203 static NTSTATUS
1204 do_create_file(PHANDLE FileHandle,
1205                ACCESS_MASK DesiredAccess,
1206                PLARGE_INTEGER AllocationSize,
1207                ULONG FileAttributes,
1208                ULONG CreateDisposition,
1209                ULONG CreateOptions,
1210                struct win32_apply_ctx *ctx)
1211 {
1212         return (*func_NtCreateFile)(FileHandle,
1213                                     DesiredAccess,
1214                                     &ctx->attr,
1215                                     &ctx->iosb,
1216                                     AllocationSize,
1217                                     FileAttributes,
1218                                     FILE_SHARE_VALID_FLAGS,
1219                                     CreateDisposition,
1220                                     CreateOptions |
1221                                         FILE_OPEN_FOR_BACKUP_INTENT |
1222                                         FILE_OPEN_REPARSE_POINT,
1223                                     NULL,
1224                                     0);
1225 }
1226
1227 /* Like do_create_file(), but builds the extraction path of the @dentry first.
1228  */
1229 static NTSTATUS
1230 create_file(PHANDLE FileHandle,
1231             ACCESS_MASK DesiredAccess,
1232             PLARGE_INTEGER AllocationSize,
1233             ULONG FileAttributes,
1234             ULONG CreateDisposition,
1235             ULONG CreateOptions,
1236             const struct wim_dentry *dentry,
1237             struct win32_apply_ctx *ctx)
1238 {
1239         build_extraction_path(dentry, ctx);
1240         return do_create_file(FileHandle,
1241                               DesiredAccess,
1242                               AllocationSize,
1243                               FileAttributes,
1244                               CreateDisposition,
1245                               CreateOptions,
1246                               ctx);
1247 }
1248
1249 /* Create empty named data streams.
1250  *
1251  * Since these won't have 'struct wim_lookup_table_entry's, they won't show up
1252  * in the call to extract_stream_list().  Hence the need for the special case.
1253  */
1254 static int
1255 create_any_empty_ads(const struct wim_dentry *dentry,
1256                      struct win32_apply_ctx *ctx)
1257 {
1258         const struct wim_inode *inode = dentry->d_inode;
1259         LARGE_INTEGER allocation_size;
1260         bool path_modified = false;
1261         int ret = 0;
1262
1263         if (!ctx->common.supported_features.named_data_streams)
1264                 return 0;
1265
1266         for (u16 i = 0; i < inode->i_num_ads; i++) {
1267                 const struct wim_ads_entry *entry;
1268                 NTSTATUS status;
1269                 HANDLE h;
1270                 bool retried;
1271                 DWORD disposition;
1272
1273                 entry = &inode->i_ads_entries[i];
1274
1275                 /* Not named?  */
1276                 if (!entry->stream_name_nbytes)
1277                         continue;
1278
1279                 /* Not empty?  */
1280                 if (entry->lte)
1281                         continue;
1282
1283                 /* Probably setting the allocation size to 0 has no effect, but
1284                  * we might as well try.  */
1285                 allocation_size.QuadPart = 0;
1286
1287                 build_extraction_path_with_ads(dentry, ctx,
1288                                                entry->stream_name,
1289                                                entry->stream_name_nbytes /
1290                                                         sizeof(wchar_t));
1291                 path_modified = true;
1292
1293                 retried = false;
1294                 disposition = FILE_SUPERSEDE;
1295         retry:
1296                 status = do_create_file(&h, FILE_WRITE_DATA, &allocation_size,
1297                                         0, disposition, 0, ctx);
1298                 if (unlikely(!NT_SUCCESS(status))) {
1299                         if (status == STATUS_OBJECT_NAME_NOT_FOUND && !retried) {
1300                                 /* Workaround for defect in the Windows PE
1301                                  * in-memory filesystem implementation:
1302                                  * FILE_SUPERSEDE does not create the file, as
1303                                  * expected and documented, when the named file
1304                                  * does not exist.  */
1305                                 retried = true;
1306                                 disposition = FILE_CREATE;
1307                                 goto retry;
1308                         }
1309                         set_errno_from_nt_status(status);
1310                         ERROR_WITH_ERRNO("Can't create \"%ls\" "
1311                                          "(status=0x%08"PRIx32")",
1312                                          current_path(ctx), (u32)status);
1313                         ret = WIMLIB_ERR_OPEN;
1314                         break;
1315                 }
1316                 (*func_NtClose)(h);
1317         }
1318         /* Restore the path to the dentry itself  */
1319         if (path_modified)
1320                 build_extraction_path(dentry, ctx);
1321         return ret;
1322 }
1323
1324 /*
1325  * Creates the directory named by @dentry, or uses an existing directory at that
1326  * location.  If necessary, sets the short name and/or fixes compression and
1327  * encryption attributes.
1328  *
1329  * Returns 0, WIMLIB_ERR_MKDIR, or WIMLIB_ERR_SET_SHORT_NAME.
1330  */
1331 static int
1332 create_directory(const struct wim_dentry *dentry,
1333                  struct win32_apply_ctx *ctx)
1334 {
1335         HANDLE h;
1336         NTSTATUS status;
1337         int ret;
1338         ULONG attrib;
1339
1340         /* Special attributes:
1341          *
1342          * Use FILE_ATTRIBUTE_ENCRYPTED if the directory needs to have it set.
1343          * This doesn't work for FILE_ATTRIBUTE_COMPRESSED (unfortunately).
1344          *
1345          * Don't specify FILE_ATTRIBUTE_DIRECTORY; it gets set anyway as a
1346          * result of the FILE_DIRECTORY_FILE option.  */
1347         attrib = (dentry->d_inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED);
1348
1349         /* DELETE is needed for set_short_name().
1350          * GENERIC_READ and GENERIC_WRITE are needed for
1351          * adjust_compression_attribute().  */
1352         status = create_file(&h, GENERIC_READ | GENERIC_WRITE | DELETE, NULL,
1353                              attrib, FILE_OPEN_IF, FILE_DIRECTORY_FILE,
1354                              dentry, ctx);
1355         if (!NT_SUCCESS(status)) {
1356                 set_errno_from_nt_status(status);
1357                 ERROR_WITH_ERRNO("Can't create directory \"%ls\" "
1358                                  "(status=0x%08"PRIx32")",
1359                                  current_path(ctx), (u32)status);
1360                 return WIMLIB_ERR_MKDIR;
1361         }
1362
1363         ret = set_short_name(h, dentry, ctx);
1364
1365         if (!ret)
1366                 ret = adjust_compression_attribute(h, dentry, ctx);
1367
1368         if (!ret)
1369                 ret = maybe_clear_encryption_attribute(&h, dentry, ctx);
1370                 /* May close the handle!!! */
1371
1372         if (h)
1373                 (*func_NtClose)(h);
1374         return ret;
1375 }
1376
1377 /*
1378  * Create all the directories being extracted, other than the target directory
1379  * itself.
1380  *
1381  * Note: we don't honor directory hard links.  However, we don't allow them to
1382  * exist in WIM images anyway (see inode_fixup.c).
1383  */
1384 static int
1385 create_directories(struct list_head *dentry_list,
1386                    struct win32_apply_ctx *ctx)
1387 {
1388         const struct wim_dentry *dentry;
1389         int ret;
1390
1391         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
1392
1393                 if (!(dentry->d_inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY))
1394                         continue;
1395
1396                 /* Note: Here we include files with
1397                  * FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT, but we
1398                  * wait until later to actually set the reparse data.  */
1399
1400                 /* If the root dentry is being extracted, it was already done so
1401                  * in prepare_target().  */
1402                 if (!dentry_is_root(dentry)) {
1403                         ret = create_directory(dentry, ctx);
1404                         ret = check_apply_error(dentry, ctx, ret);
1405                         if (ret)
1406                                 return ret;
1407
1408                         ret = create_any_empty_ads(dentry, ctx);
1409                         ret = check_apply_error(dentry, ctx, ret);
1410                         if (ret)
1411                                 return ret;
1412                 }
1413
1414                 ret = report_file_created(&ctx->common);
1415                 if (ret)
1416                         return ret;
1417         }
1418         return 0;
1419 }
1420
1421 /*
1422  * Creates the nondirectory file named by @dentry.
1423  *
1424  * On success, returns an open handle to the file in @h_ret, with GENERIC_READ,
1425  * GENERIC_WRITE, and DELETE access.  Also, the path to the file will be saved
1426  * in ctx->pathbuf.  On failure, returns WIMLIB_ERR_OPEN.
1427  */
1428 static int
1429 create_nondirectory_inode(HANDLE *h_ret, const struct wim_dentry *dentry,
1430                           struct win32_apply_ctx *ctx)
1431 {
1432         const struct wim_inode *inode;
1433         ULONG attrib;
1434         NTSTATUS status;
1435         bool retried = false;
1436         DWORD disposition;
1437
1438         inode = dentry->d_inode;
1439
1440         /* If the file already exists and has FILE_ATTRIBUTE_SYSTEM and/or
1441          * FILE_ATTRIBUTE_HIDDEN, these must be specified in order to supersede
1442          * the file.
1443          *
1444          * Normally the user shouldn't be trying to overwrite such files anyway,
1445          * but we at least provide FILE_ATTRIBUTE_SYSTEM and
1446          * FILE_ATTRIBUTE_HIDDEN if the WIM inode has those attributes so that
1447          * we catch the case where the user extracts the same files to the same
1448          * location more than one time.
1449          *
1450          * Also specify FILE_ATTRIBUTE_ENCRYPTED if the file needs to be
1451          * encrypted.
1452          *
1453          * In NO_ATTRIBUTES mode just don't specify any attributes at all.
1454          */
1455         if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES) {
1456                 attrib = 0;
1457         } else {
1458                 attrib = (inode->i_attributes & (FILE_ATTRIBUTE_SYSTEM |
1459                                                  FILE_ATTRIBUTE_HIDDEN |
1460                                                  FILE_ATTRIBUTE_ENCRYPTED));
1461         }
1462         build_extraction_path(dentry, ctx);
1463         disposition = FILE_SUPERSEDE;
1464 retry:
1465         status = do_create_file(h_ret, GENERIC_READ | GENERIC_WRITE | DELETE,
1466                                 NULL, attrib, disposition,
1467                                 FILE_NON_DIRECTORY_FILE, ctx);
1468         if (likely(NT_SUCCESS(status))) {
1469                 int ret;
1470
1471                 ret = adjust_compression_attribute(*h_ret, dentry, ctx);
1472                 if (ret) {
1473                         (*func_NtClose)(*h_ret);
1474                         return ret;
1475                 }
1476
1477                 ret = maybe_clear_encryption_attribute(h_ret, dentry, ctx);
1478                 /* May close the handle!!! */
1479
1480                 if (ret) {
1481                         if (*h_ret)
1482                                 (*func_NtClose)(*h_ret);
1483                         return ret;
1484                 }
1485
1486                 if (!*h_ret) {
1487                         /* Re-open the handle so that we can return it on
1488                          * success.  */
1489                         status = do_create_file(h_ret,
1490                                                 GENERIC_READ |
1491                                                         GENERIC_WRITE | DELETE,
1492                                                 NULL, 0, FILE_OPEN,
1493                                                 FILE_NON_DIRECTORY_FILE, ctx);
1494                         if (!NT_SUCCESS(status))
1495                                 goto fail;
1496                 }
1497
1498                 ret = create_any_empty_ads(dentry, ctx);
1499                 if (ret) {
1500                         (*func_NtClose)(*h_ret);
1501                         return ret;
1502                 }
1503                 return 0;
1504         }
1505
1506         if (status == STATUS_OBJECT_NAME_NOT_FOUND && !retried) {
1507                 /* Workaround for defect in the Windows PE in-memory filesystem
1508                  * implementation: FILE_SUPERSEDE does not create the file, as
1509                  * expected and documented, when the named file does not exist.
1510                  */
1511                 retried = true;
1512                 disposition = FILE_CREATE;
1513                 goto retry;
1514         }
1515
1516         if (status == STATUS_ACCESS_DENIED && !retried) {
1517                 /* We also can't supersede an existing file that has
1518                  * FILE_ATTRIBUTE_READONLY set; doing so causes NtCreateFile()
1519                  * to return STATUS_ACCESS_DENIED .  The only workaround seems
1520                  * to be to explicitly remove FILE_ATTRIBUTE_READONLY on the
1521                  * existing file, then try again.  */
1522
1523                 FILE_BASIC_INFORMATION info;
1524                 HANDLE h;
1525
1526                 status = do_create_file(&h, FILE_WRITE_ATTRIBUTES, NULL, 0,
1527                                         FILE_OPEN, FILE_NON_DIRECTORY_FILE, ctx);
1528                 if (!NT_SUCCESS(status))
1529                         goto fail;
1530
1531                 memset(&info, 0, sizeof(info));
1532                 info.FileAttributes = FILE_ATTRIBUTE_NORMAL;
1533
1534                 status = (*func_NtSetInformationFile)(h, &ctx->iosb,
1535                                                       &info, sizeof(info),
1536                                                       FileBasicInformation);
1537                 (*func_NtClose)(h);
1538                 if (!NT_SUCCESS(status))
1539                         goto fail;
1540                 retried = true;
1541                 goto retry;
1542         }
1543 fail:
1544         set_errno_from_nt_status(status);
1545         ERROR_WITH_ERRNO("Can't create file \"%ls\" (status=0x%08"PRIx32")",
1546                          current_path(ctx), (u32)status);
1547         return WIMLIB_ERR_OPEN;
1548 }
1549
1550 /* Creates a hard link at the location named by @dentry to the file represented
1551  * by the open handle @h.  Or, if the target volume does not support hard links,
1552  * create a separate file instead.  */
1553 static int
1554 create_link(HANDLE h, const struct wim_dentry *dentry,
1555             struct win32_apply_ctx *ctx)
1556 {
1557         if (ctx->common.supported_features.hard_links) {
1558
1559                 build_extraction_path(dentry, ctx);
1560
1561                 size_t bufsize = offsetof(FILE_LINK_INFORMATION, FileName) +
1562                                  ctx->pathbuf.Length + sizeof(wchar_t);
1563                 u8 buf[bufsize] _aligned_attribute(8);
1564                 FILE_LINK_INFORMATION *info = (FILE_LINK_INFORMATION *)buf;
1565                 NTSTATUS status;
1566
1567                 info->ReplaceIfExists = TRUE;
1568                 info->RootDirectory = ctx->attr.RootDirectory;
1569                 info->FileNameLength = ctx->pathbuf.Length;
1570                 memcpy(info->FileName, ctx->pathbuf.Buffer, ctx->pathbuf.Length);
1571                 info->FileName[info->FileNameLength / 2] = L'\0';
1572
1573                 /* Note: the null terminator isn't actually necessary,
1574                  * but if you don't add the extra character, you get
1575                  * STATUS_INFO_LENGTH_MISMATCH when FileNameLength
1576                  * happens to be 2  */
1577
1578                 status = (*func_NtSetInformationFile)(h, &ctx->iosb,
1579                                                       info, bufsize,
1580                                                       FileLinkInformation);
1581                 if (NT_SUCCESS(status))
1582                         return 0;
1583                 ERROR("Failed to create link \"%ls\" (status=0x%08"PRIx32")",
1584                       current_path(ctx), (u32)status);
1585                 return WIMLIB_ERR_LINK;
1586         } else {
1587                 HANDLE h2;
1588                 int ret;
1589
1590                 ret = create_nondirectory_inode(&h2, dentry, ctx);
1591                 if (ret)
1592                         return ret;
1593
1594                 (*func_NtClose)(h2);
1595                 return 0;
1596         }
1597 }
1598
1599 /* Given an inode (represented by the open handle @h) for which one link has
1600  * been created (named by @first_dentry), create the other links.
1601  *
1602  * Or, if the target volume does not support hard links, create separate files.
1603  *
1604  * Note: This uses ctx->pathbuf and does not reset it.
1605  */
1606 static int
1607 create_links(HANDLE h, const struct wim_dentry *first_dentry,
1608              struct win32_apply_ctx *ctx)
1609 {
1610         const struct wim_inode *inode;
1611         const struct list_head *next;
1612         const struct wim_dentry *dentry;
1613         int ret;
1614
1615         inode = first_dentry->d_inode;
1616         next = inode->i_extraction_aliases.next;
1617         do {
1618                 dentry = list_entry(next, struct wim_dentry,
1619                                     d_extraction_alias_node);
1620                 if (dentry != first_dentry) {
1621                         ret = create_link(h, dentry, ctx);
1622                         if (ret)
1623                                 return ret;
1624                 }
1625                 next = next->next;
1626         } while (next != &inode->i_extraction_aliases);
1627         return 0;
1628 }
1629
1630 /* Create a nondirectory file, including all links.  */
1631 static int
1632 create_nondirectory(struct wim_inode *inode, struct win32_apply_ctx *ctx)
1633 {
1634         struct wim_dentry *first_dentry;
1635         HANDLE h;
1636         int ret;
1637
1638         first_dentry = first_extraction_alias(inode);
1639
1640         /* Create first link.  */
1641         ret = create_nondirectory_inode(&h, first_dentry, ctx);
1642         if (ret)
1643                 return ret;
1644
1645         /* Set short name.  */
1646         ret = set_short_name(h, first_dentry, ctx);
1647
1648         /* Create additional links, OR if hard links are not supported just
1649          * create more files.  */
1650         if (!ret)
1651                 ret = create_links(h, first_dentry, ctx);
1652
1653         /* "WIMBoot" extraction: set external backing by the WIM file if needed.  */
1654         if (!ret && unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT))
1655                 ret = set_external_backing(h, inode, ctx);
1656
1657         (*func_NtClose)(h);
1658         return ret;
1659 }
1660
1661 /* Create all the nondirectory files being extracted, including all aliases
1662  * (hard links).  */
1663 static int
1664 create_nondirectories(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
1665 {
1666         struct wim_dentry *dentry;
1667         struct wim_inode *inode;
1668         int ret;
1669
1670         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
1671                 inode = dentry->d_inode;
1672                 if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
1673                         continue;
1674                 /* Call create_nondirectory() only once per inode  */
1675                 if (dentry == inode_first_extraction_dentry(inode)) {
1676                         ret = create_nondirectory(inode, ctx);
1677                         ret = check_apply_error(dentry, ctx, ret);
1678                         if (ret)
1679                                 return ret;
1680                 }
1681                 ret = report_file_created(&ctx->common);
1682                 if (ret)
1683                         return ret;
1684         }
1685         return 0;
1686 }
1687
1688 static void
1689 close_handles(struct win32_apply_ctx *ctx)
1690 {
1691         for (unsigned i = 0; i < ctx->num_open_handles; i++)
1692                 (*func_NtClose)(ctx->open_handles[i]);
1693 }
1694
1695 /* Prepare to read the next stream, which has size @stream_size, into an
1696  * in-memory buffer.  */
1697 static bool
1698 prepare_data_buffer(struct win32_apply_ctx *ctx, u64 stream_size)
1699 {
1700         if (stream_size > ctx->data_buffer_size) {
1701                 /* Larger buffer needed.  */
1702                 void *new_buffer;
1703                 if ((size_t)stream_size != stream_size)
1704                         return false;
1705                 new_buffer = REALLOC(ctx->data_buffer, stream_size);
1706                 if (!new_buffer)
1707                         return false;
1708                 ctx->data_buffer = new_buffer;
1709                 ctx->data_buffer_size = stream_size;
1710         }
1711         /* On the first call this changes data_buffer_ptr from NULL, which tells
1712          * extract_chunk() that the data buffer needs to be filled while reading
1713          * the stream data.  */
1714         ctx->data_buffer_ptr = ctx->data_buffer;
1715         return true;
1716 }
1717
1718 static int
1719 begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
1720                               struct wim_dentry *dentry,
1721                               const wchar_t *stream_name,
1722                               struct win32_apply_ctx *ctx)
1723 {
1724         const struct wim_inode *inode = dentry->d_inode;
1725         size_t stream_name_nchars = 0;
1726         FILE_ALLOCATION_INFORMATION alloc_info;
1727         HANDLE h;
1728         NTSTATUS status;
1729
1730         if (unlikely(stream_name))
1731                 stream_name_nchars = wcslen(stream_name);
1732
1733         if (unlikely(stream_name_nchars)) {
1734                 build_extraction_path_with_ads(dentry, ctx,
1735                                                stream_name, stream_name_nchars);
1736         } else {
1737                 build_extraction_path(dentry, ctx);
1738         }
1739
1740         /* Reparse point?  */
1741         if (unlikely(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT)
1742             && (stream_name_nchars == 0))
1743         {
1744                 if (!ctx->common.supported_features.reparse_points)
1745                         return 0;
1746
1747                 /* We can't write the reparse stream directly; we must set it
1748                  * with FSCTL_SET_REPARSE_POINT, which requires that all the
1749                  * data be available.  So, stage the data in a buffer.  */
1750
1751                 if (!prepare_data_buffer(ctx, stream->size))
1752                         return WIMLIB_ERR_NOMEM;
1753                 list_add_tail(&dentry->tmp_list, &ctx->reparse_dentries);
1754                 return 0;
1755         }
1756
1757         /* Encrypted file?  */
1758         if (unlikely(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED)
1759             && (stream_name_nchars == 0))
1760         {
1761                 if (!ctx->common.supported_features.encrypted_files)
1762                         return 0;
1763
1764                 /* We can't write encrypted file streams directly; we must use
1765                  * WriteEncryptedFileRaw(), which requires providing the data
1766                  * through a callback function.  This can't easily be combined
1767                  * with our own callback-based approach.
1768                  *
1769                  * The current workaround is to simply read the stream into
1770                  * memory and write the encrypted file from that.
1771                  *
1772                  * TODO: This isn't sufficient for extremely large encrypted
1773                  * files.  Perhaps we should create an extra thread to write
1774                  * such files...  */
1775                 if (!prepare_data_buffer(ctx, stream->size))
1776                         return WIMLIB_ERR_NOMEM;
1777                 list_add_tail(&dentry->tmp_list, &ctx->encrypted_dentries);
1778                 return 0;
1779         }
1780
1781         if (ctx->num_open_handles == MAX_OPEN_STREAMS) {
1782                 /* XXX: Fix this.  But because of the checks in
1783                  * extract_stream_list(), this can now only happen on a
1784                  * filesystem that does not support hard links.  */
1785                 ERROR("Can't extract data: too many open files!");
1786                 return WIMLIB_ERR_UNSUPPORTED;
1787         }
1788
1789         /* Open a new handle  */
1790         status = do_create_file(&h,
1791                                 FILE_WRITE_DATA | SYNCHRONIZE,
1792                                 NULL, 0, FILE_OPEN_IF,
1793                                 FILE_SEQUENTIAL_ONLY |
1794                                         FILE_SYNCHRONOUS_IO_NONALERT,
1795                                 ctx);
1796         if (!NT_SUCCESS(status)) {
1797                 set_errno_from_nt_status(status);
1798                 ERROR_WITH_ERRNO("Can't open \"%ls\" for writing "
1799                                  "(status=0x%08"PRIx32")",
1800                                  current_path(ctx), (u32)status);
1801                 return WIMLIB_ERR_OPEN;
1802         }
1803
1804         ctx->open_handles[ctx->num_open_handles++] = h;
1805
1806         /* Allocate space for the data.  */
1807         alloc_info.AllocationSize.QuadPart = stream->size;
1808         (*func_NtSetInformationFile)(h, &ctx->iosb,
1809                                      &alloc_info, sizeof(alloc_info),
1810                                      FileAllocationInformation);
1811         return 0;
1812 }
1813
1814 /* Set the reparse data @rpbuf of length @rpbuflen on the extracted file
1815  * corresponding to the WIM dentry @dentry.  */
1816 static int
1817 do_set_reparse_data(const struct wim_dentry *dentry,
1818                     const void *rpbuf, u16 rpbuflen,
1819                     struct win32_apply_ctx *ctx)
1820 {
1821         NTSTATUS status;
1822         HANDLE h;
1823
1824         status = create_file(&h, GENERIC_WRITE, NULL,
1825                              0, FILE_OPEN, 0, dentry, ctx);
1826         if (!NT_SUCCESS(status))
1827                 goto fail;
1828
1829         status = (*func_NtFsControlFile)(h, NULL, NULL, NULL,
1830                                          &ctx->iosb, FSCTL_SET_REPARSE_POINT,
1831                                          (void *)rpbuf, rpbuflen,
1832                                          NULL, 0);
1833         (*func_NtClose)(h);
1834
1835         if (NT_SUCCESS(status))
1836                 return 0;
1837
1838         /* On Windows, by default only the Administrator can create symbolic
1839          * links for some reason.  By default we just issue a warning if this
1840          * appears to be the problem.  Use WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS
1841          * to get a hard error.  */
1842         if (!(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS)
1843             && (status == STATUS_PRIVILEGE_NOT_HELD ||
1844                 status == STATUS_ACCESS_DENIED)
1845             && (dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
1846                 dentry->d_inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))
1847         {
1848                 WARNING("Can't create symbolic link \"%ls\"!              \n"
1849                         "          (Need Administrator rights, or at least "
1850                         "the\n"
1851                         "          SeCreateSymbolicLink privilege.)",
1852                         current_path(ctx));
1853                 return 0;
1854         }
1855
1856 fail:
1857         set_errno_from_nt_status(status);
1858         ERROR_WITH_ERRNO("Can't set reparse data on \"%ls\" "
1859                          "(status=0x%08"PRIx32")",
1860                          current_path(ctx), (u32)status);
1861         return WIMLIB_ERR_SET_REPARSE_DATA;
1862 }
1863
1864 /* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
1865  * pointer to the suffix of the path that begins with the device directly, such
1866  * as e:\Windows\System32.  */
1867 static const wchar_t *
1868 skip_nt_toplevel_component(const wchar_t *path, size_t path_nchars)
1869 {
1870         static const wchar_t * const dirs[] = {
1871                 L"\\??\\",
1872                 L"\\DosDevices\\",
1873                 L"\\Device\\",
1874         };
1875         size_t first_dir_len = 0;
1876         const wchar_t * const end = path + path_nchars;
1877
1878         for (size_t i = 0; i < ARRAY_LEN(dirs); i++) {
1879                 size_t len = wcslen(dirs[i]);
1880                 if (len <= (end - path) && !wcsnicmp(path, dirs[i], len)) {
1881                         first_dir_len = len;
1882                         break;
1883                 }
1884         }
1885         if (first_dir_len == 0)
1886                 return path;
1887         path += first_dir_len;
1888         while (path != end && *path == L'\\')
1889                 path++;
1890         return path;
1891 }
1892
1893 /* Given a Windows NT namespace path, such as \??\e:\Windows\System32, return a
1894  * pointer to the suffix of the path that is device-relative, such as
1895  * Windows\System32.
1896  *
1897  * The path has an explicit length and is not necessarily null terminated.
1898  *
1899  * If the path just something like \??\e: then the returned pointer will point
1900  * just past the colon.  In this case the length of the result will be 0
1901  * characters.  */
1902 static const wchar_t *
1903 get_device_relative_path(const wchar_t *path, size_t path_nchars)
1904 {
1905         const wchar_t * const orig_path = path;
1906         const wchar_t * const end = path + path_nchars;
1907
1908         path = skip_nt_toplevel_component(path, path_nchars);
1909         if (path == orig_path)
1910                 return orig_path;
1911
1912         path = wmemchr(path, L'\\', (end - path));
1913         if (!path)
1914                 return end;
1915         do {
1916                 path++;
1917         } while (path != end && *path == L'\\');
1918         return path;
1919 }
1920
1921 /*
1922  * Given a reparse point buffer for a symbolic link or junction, adjust its
1923  * contents so that the target of the link is consistent with the new location
1924  * of the files.
1925  */
1926 static void
1927 try_rpfix(u8 *rpbuf, u16 *rpbuflen_p, struct win32_apply_ctx *ctx)
1928 {
1929         struct reparse_data rpdata;
1930         size_t orig_subst_name_nchars;
1931         const wchar_t *relpath;
1932         size_t relpath_nchars;
1933         size_t target_ntpath_nchars;
1934         size_t fixed_subst_name_nchars;
1935         const wchar_t *fixed_print_name;
1936         size_t fixed_print_name_nchars;
1937
1938         if (parse_reparse_data(rpbuf, *rpbuflen_p, &rpdata)) {
1939                 /* Do nothing if the reparse data is invalid.  */
1940                 return;
1941         }
1942
1943         if (rpdata.rptag == WIM_IO_REPARSE_TAG_SYMLINK &&
1944             (rpdata.rpflags & SYMBOLIC_LINK_RELATIVE))
1945         {
1946                 /* Do nothing if it's a relative symbolic link.  */
1947                 return;
1948         }
1949
1950         /* Build the new substitute name from the NT namespace path to the
1951          * target directory, then a path separator, then the "device relative"
1952          * part of the old substitute name.  */
1953
1954         orig_subst_name_nchars = rpdata.substitute_name_nbytes / sizeof(wchar_t);
1955
1956         relpath = get_device_relative_path(rpdata.substitute_name,
1957                                            orig_subst_name_nchars);
1958         relpath_nchars = orig_subst_name_nchars -
1959                          (relpath - rpdata.substitute_name);
1960
1961         target_ntpath_nchars = ctx->target_ntpath.Length / sizeof(wchar_t);
1962
1963         fixed_subst_name_nchars = target_ntpath_nchars;
1964         if (relpath_nchars)
1965                 fixed_subst_name_nchars += 1 + relpath_nchars;
1966         wchar_t fixed_subst_name[fixed_subst_name_nchars];
1967
1968         wmemcpy(fixed_subst_name, ctx->target_ntpath.Buffer,
1969                 target_ntpath_nchars);
1970         if (relpath_nchars) {
1971                 fixed_subst_name[target_ntpath_nchars] = L'\\';
1972                 wmemcpy(&fixed_subst_name[target_ntpath_nchars + 1],
1973                         relpath, relpath_nchars);
1974         }
1975         /* Doesn't need to be null-terminated.  */
1976
1977         /* Print name should be Win32, but not all NT names can even be
1978          * translated to Win32 names.  But we can at least delete the top-level
1979          * directory, such as \??\, and this will have the expected result in
1980          * the usual case.  */
1981         fixed_print_name = skip_nt_toplevel_component(fixed_subst_name,
1982                                                       fixed_subst_name_nchars);
1983         fixed_print_name_nchars = fixed_subst_name_nchars - (fixed_print_name -
1984                                                              fixed_subst_name);
1985
1986         rpdata.substitute_name = fixed_subst_name;
1987         rpdata.substitute_name_nbytes = fixed_subst_name_nchars * sizeof(wchar_t);
1988         rpdata.print_name = (wchar_t *)fixed_print_name;
1989         rpdata.print_name_nbytes = fixed_print_name_nchars * sizeof(wchar_t);
1990         make_reparse_buffer(&rpdata, rpbuf, rpbuflen_p);
1991 }
1992
1993 /* Sets reparse data on the specified file.  This handles "fixing" the targets
1994  * of absolute symbolic links and junctions if WIMLIB_EXTRACT_FLAG_RPFIX was
1995  * specified.  */
1996 static int
1997 set_reparse_data(const struct wim_dentry *dentry,
1998                  const void *_rpbuf, u16 rpbuflen, struct win32_apply_ctx *ctx)
1999 {
2000         const struct wim_inode *inode = dentry->d_inode;
2001         const void *rpbuf = _rpbuf;
2002
2003         if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX)
2004             && !inode->i_not_rpfixed
2005             && (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
2006                 inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT))
2007         {
2008                 memcpy(&ctx->rpfixbuf, _rpbuf, rpbuflen);
2009                 try_rpfix((u8 *)&ctx->rpfixbuf, &rpbuflen, ctx);
2010                 rpbuf = &ctx->rpfixbuf;
2011         }
2012         return do_set_reparse_data(dentry, rpbuf, rpbuflen, ctx);
2013
2014 }
2015
2016 /* Import the next block of raw encrypted data  */
2017 static DWORD WINAPI
2018 import_encrypted_data(PBYTE pbData, PVOID pvCallbackContext, PULONG Length)
2019 {
2020         struct win32_apply_ctx *ctx = pvCallbackContext;
2021         ULONG copy_len;
2022
2023         copy_len = min(ctx->encrypted_size - ctx->encrypted_offset, *Length);
2024         memcpy(pbData, &ctx->data_buffer[ctx->encrypted_offset], copy_len);
2025         ctx->encrypted_offset += copy_len;
2026         *Length = copy_len;
2027         return ERROR_SUCCESS;
2028 }
2029
2030 /* Write the raw encrypted data to the already-created file corresponding to
2031  * @dentry.
2032  *
2033  * The raw encrypted data is provided in ctx->data_buffer, and its size is
2034  * ctx->encrypted_size.  */
2035 static int
2036 extract_encrypted_file(const struct wim_dentry *dentry,
2037                        struct win32_apply_ctx *ctx)
2038 {
2039         void *rawctx;
2040         DWORD err;
2041
2042         /* Temporarily build a Win32 path for OpenEncryptedFileRaw()  */
2043         build_win32_extraction_path(dentry, ctx);
2044
2045         err = OpenEncryptedFileRaw(ctx->pathbuf.Buffer,
2046                                    CREATE_FOR_IMPORT, &rawctx);
2047
2048         /* Restore the NT namespace path  */
2049         build_extraction_path(dentry, ctx);
2050
2051         if (err != ERROR_SUCCESS) {
2052                 set_errno_from_win32_error(err);
2053                 ERROR_WITH_ERRNO("Can't open \"%ls\" for encrypted import "
2054                                  "(err=%"PRIu32")", current_path(ctx), (u32)err);
2055                 return WIMLIB_ERR_OPEN;
2056         }
2057
2058         ctx->encrypted_offset = 0;
2059
2060         err = WriteEncryptedFileRaw(import_encrypted_data, ctx, rawctx);
2061
2062         CloseEncryptedFileRaw(rawctx);
2063
2064         if (err != ERROR_SUCCESS) {
2065                 set_errno_from_win32_error(err);
2066                 ERROR_WITH_ERRNO("Can't import encrypted file \"%ls\" "
2067                                  "(err=%"PRIu32")", current_path(ctx), (u32)err);
2068                 return WIMLIB_ERR_WRITE;
2069         }
2070
2071         return 0;
2072 }
2073
2074 /* Called when starting to read a stream for extraction on Windows  */
2075 static int
2076 begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx)
2077 {
2078         struct win32_apply_ctx *ctx = _ctx;
2079         const struct stream_owner *owners = stream_owners(stream);
2080         int ret;
2081
2082         ctx->num_open_handles = 0;
2083         ctx->data_buffer_ptr = NULL;
2084         INIT_LIST_HEAD(&ctx->reparse_dentries);
2085         INIT_LIST_HEAD(&ctx->encrypted_dentries);
2086
2087         for (u32 i = 0; i < stream->out_refcnt; i++) {
2088                 const struct wim_inode *inode = owners[i].inode;
2089                 const wchar_t *stream_name = owners[i].stream_name;
2090                 struct wim_dentry *dentry;
2091
2092                 /* A copy of the stream needs to be extracted to @inode.  */
2093
2094                 if (ctx->common.supported_features.hard_links) {
2095                         dentry = inode_first_extraction_dentry(inode);
2096                         ret = begin_extract_stream_instance(stream, dentry,
2097                                                             stream_name, ctx);
2098                         ret = check_apply_error(dentry, ctx, ret);
2099                         if (ret)
2100                                 goto fail;
2101                 } else {
2102                         /* Hard links not supported.  Extract the stream
2103                          * separately to each alias of the inode.  */
2104                         struct list_head *next;
2105
2106                         next = inode->i_extraction_aliases.next;
2107                         do {
2108                                 dentry = list_entry(next, struct wim_dentry,
2109                                                     d_extraction_alias_node);
2110                                 ret = begin_extract_stream_instance(stream,
2111                                                                     dentry,
2112                                                                     stream_name,
2113                                                                     ctx);
2114                                 ret = check_apply_error(dentry, ctx, ret);
2115                                 if (ret)
2116                                         goto fail;
2117                                 next = next->next;
2118                         } while (next != &inode->i_extraction_aliases);
2119                 }
2120         }
2121
2122         return 0;
2123
2124 fail:
2125         close_handles(ctx);
2126         return ret;
2127 }
2128
2129 /* Called when the next chunk of a stream has been read for extraction on
2130  * Windows  */
2131 static int
2132 extract_chunk(const void *chunk, size_t size, void *_ctx)
2133 {
2134         struct win32_apply_ctx *ctx = _ctx;
2135
2136         /* Write the data chunk to each open handle  */
2137         for (unsigned i = 0; i < ctx->num_open_handles; i++) {
2138                 u8 *bufptr = (u8 *)chunk;
2139                 size_t bytes_remaining = size;
2140                 NTSTATUS status;
2141                 while (bytes_remaining) {
2142                         ULONG count = min(0xFFFFFFFF, bytes_remaining);
2143
2144                         status = (*func_NtWriteFile)(ctx->open_handles[i],
2145                                                      NULL, NULL, NULL,
2146                                                      &ctx->iosb, bufptr, count,
2147                                                      NULL, NULL);
2148                         if (!NT_SUCCESS(status)) {
2149                                 set_errno_from_nt_status(status);
2150                                 ERROR_WITH_ERRNO("Error writing data to target "
2151                                                  "volume (status=0x%08"PRIx32")",
2152                                                  (u32)status);
2153                                 return WIMLIB_ERR_WRITE;
2154                         }
2155                         bufptr += ctx->iosb.Information;
2156                         bytes_remaining -= ctx->iosb.Information;
2157                 }
2158         }
2159
2160         /* Copy the data chunk into the buffer (if needed)  */
2161         if (ctx->data_buffer_ptr)
2162                 ctx->data_buffer_ptr = mempcpy(ctx->data_buffer_ptr,
2163                                                chunk, size);
2164         return 0;
2165 }
2166
2167 /* Called when a stream has been fully read for extraction on Windows  */
2168 static int
2169 end_extract_stream(struct wim_lookup_table_entry *stream, int status, void *_ctx)
2170 {
2171         struct win32_apply_ctx *ctx = _ctx;
2172         int ret;
2173         const struct wim_dentry *dentry;
2174
2175         close_handles(ctx);
2176
2177         if (status)
2178                 return status;
2179
2180         if (likely(!ctx->data_buffer_ptr))
2181                 return 0;
2182
2183         if (!list_empty(&ctx->reparse_dentries)) {
2184                 if (stream->size > REPARSE_DATA_MAX_SIZE) {
2185                         dentry = list_first_entry(&ctx->reparse_dentries,
2186                                                   struct wim_dentry, tmp_list);
2187                         build_extraction_path(dentry, ctx);
2188                         ERROR("Reparse data of \"%ls\" has size "
2189                               "%"PRIu64" bytes (exceeds %u bytes)",
2190                               current_path(ctx), stream->size,
2191                               REPARSE_DATA_MAX_SIZE);
2192                         ret = WIMLIB_ERR_INVALID_REPARSE_DATA;
2193                         return check_apply_error(dentry, ctx, ret);
2194                 }
2195                 /* In the WIM format, reparse streams are just the reparse data
2196                  * and omit the header.  But we can reconstruct the header.  */
2197                 memcpy(ctx->rpbuf.rpdata, ctx->data_buffer, stream->size);
2198                 ctx->rpbuf.rpdatalen = stream->size;
2199                 ctx->rpbuf.rpreserved = 0;
2200                 list_for_each_entry(dentry, &ctx->reparse_dentries, tmp_list) {
2201                         ctx->rpbuf.rptag = dentry->d_inode->i_reparse_tag;
2202                         ret = set_reparse_data(dentry, &ctx->rpbuf,
2203                                                stream->size + REPARSE_DATA_OFFSET,
2204                                                ctx);
2205                         ret = check_apply_error(dentry, ctx, ret);
2206                         if (ret)
2207                                 return ret;
2208                 }
2209         }
2210
2211         if (!list_empty(&ctx->encrypted_dentries)) {
2212                 ctx->encrypted_size = stream->size;
2213                 list_for_each_entry(dentry, &ctx->encrypted_dentries, tmp_list) {
2214                         ret = extract_encrypted_file(dentry, ctx);
2215                         ret = check_apply_error(dentry, ctx, ret);
2216                         if (ret)
2217                                 return ret;
2218                 }
2219         }
2220
2221         return 0;
2222 }
2223
2224 /* Attributes that can't be set directly  */
2225 #define SPECIAL_ATTRIBUTES                      \
2226         (FILE_ATTRIBUTE_REPARSE_POINT   |       \
2227          FILE_ATTRIBUTE_DIRECTORY       |       \
2228          FILE_ATTRIBUTE_ENCRYPTED       |       \
2229          FILE_ATTRIBUTE_SPARSE_FILE     |       \
2230          FILE_ATTRIBUTE_COMPRESSED)
2231
2232 /* Set the security descriptor @desc, of @desc_size bytes, on the file with open
2233  * handle @h.  */
2234 static NTSTATUS
2235 set_security_descriptor(HANDLE h, const void *_desc,
2236                         size_t desc_size, struct win32_apply_ctx *ctx)
2237 {
2238         SECURITY_INFORMATION info;
2239         NTSTATUS status;
2240         SECURITY_DESCRIPTOR_RELATIVE *desc;
2241
2242         /*
2243          * Ideally, we would just pass in the security descriptor buffer as-is.
2244          * But it turns out that Windows can mess up the security descriptor
2245          * even when using the low-level NtSetSecurityObject() function:
2246          *
2247          * - Windows will clear SE_DACL_AUTO_INHERITED if it is set in the
2248          *   passed buffer.  To actually get Windows to set
2249          *   SE_DACL_AUTO_INHERITED, the application must set the non-persistent
2250          *   flag SE_DACL_AUTO_INHERIT_REQ.  As usual, Microsoft didn't bother
2251          *   to properly document either of these flags.  It's unclear how
2252          *   important SE_DACL_AUTO_INHERITED actually is, but to be safe we use
2253          *   the SE_DACL_AUTO_INHERIT_REQ workaround to set it if needed.
2254          *
2255          * - The above also applies to the equivalent SACL flags,
2256          *   SE_SACL_AUTO_INHERITED and SE_SACL_AUTO_INHERIT_REQ.
2257          *
2258          * - If the application says that it's setting
2259          *   DACL_SECURITY_INFORMATION, then Windows sets SE_DACL_PRESENT in the
2260          *   resulting security descriptor, even if the security descriptor the
2261          *   application provided did not have a DACL.  This seems to be
2262          *   unavoidable, since omitting DACL_SECURITY_INFORMATION would cause a
2263          *   default DACL to remain.  Fortunately, this behavior seems harmless,
2264          *   since the resulting DACL will still be "null" --- but it will be
2265          *   "the other representation of null".
2266          *
2267          * - The above also applies to SACL_SECURITY_INFORMATION and
2268          *   SE_SACL_PRESENT.  Again, it's seemingly unavoidable but "harmless"
2269          *   that Windows changes the representation of a "null SACL".
2270          */
2271         if (likely(desc_size <= STACK_MAX)) {
2272                 desc = alloca(desc_size);
2273         } else {
2274                 desc = MALLOC(desc_size);
2275                 if (!desc)
2276                         return STATUS_NO_MEMORY;
2277         }
2278
2279         memcpy(desc, _desc, desc_size);
2280
2281         if (likely(desc_size >= 4)) {
2282
2283                 if (desc->Control & SE_DACL_AUTO_INHERITED)
2284                         desc->Control |= SE_DACL_AUTO_INHERIT_REQ;
2285
2286                 if (desc->Control & SE_SACL_AUTO_INHERITED)
2287                         desc->Control |= SE_SACL_AUTO_INHERIT_REQ;
2288         }
2289
2290         /*
2291          * More API insanity.  We want to set the entire security descriptor
2292          * as-is.  But all available APIs require specifying the specific parts
2293          * of the security descriptor being set.  Especially annoying is that
2294          * mandatory integrity labels are part of the SACL, but they aren't set
2295          * with SACL_SECURITY_INFORMATION.  Instead, applications must also
2296          * specify LABEL_SECURITY_INFORMATION (Windows Vista, Windows 7) or
2297          * BACKUP_SECURITY_INFORMATION (Windows 8).  But at least older versions
2298          * of Windows don't error out if you provide these newer flags...
2299          *
2300          * Also, if the process isn't running as Administrator, then it probably
2301          * doesn't have SE_RESTORE_PRIVILEGE.  In this case, it will always get
2302          * the STATUS_PRIVILEGE_NOT_HELD error by trying to set the SACL, even
2303          * if the security descriptor it provided did not have a SACL.  By
2304          * default, in this case we try to recover and set as much of the
2305          * security descriptor as possible --- potentially excluding the DACL, and
2306          * even the owner, as well as the SACL.
2307          */
2308
2309         info = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION |
2310                DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION |
2311                LABEL_SECURITY_INFORMATION | BACKUP_SECURITY_INFORMATION;
2312
2313
2314         /*
2315          * It's also worth noting that SetFileSecurity() is unusable because it
2316          * doesn't request "backup semantics" when it opens the file internally.
2317          * NtSetSecurityObject() seems to be the best function to use in backup
2318          * applications.  (SetSecurityInfo() should also work, but it's harder
2319          * to use and must call NtSetSecurityObject() internally anyway.
2320          * BackupWrite() is theoretically usable as well, but it's inflexible
2321          * and poorly documented.)
2322          */
2323
2324 retry:
2325         status = (*func_NtSetSecurityObject)(h, info, desc);
2326         if (NT_SUCCESS(status))
2327                 goto out_maybe_free_desc;
2328
2329         /* Failed to set the requested parts of the security descriptor.  If the
2330          * error was permissions-related, try to set fewer parts of the security
2331          * descriptor, unless WIMLIB_EXTRACT_FLAG_STRICT_ACLS is enabled.  */
2332         if ((status == STATUS_PRIVILEGE_NOT_HELD ||
2333              status == STATUS_ACCESS_DENIED) &&
2334             !(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS))
2335         {
2336                 if (info & SACL_SECURITY_INFORMATION) {
2337                         info &= ~(SACL_SECURITY_INFORMATION |
2338                                   LABEL_SECURITY_INFORMATION |
2339                                   BACKUP_SECURITY_INFORMATION);
2340                         ctx->partial_security_descriptors++;
2341                         goto retry;
2342                 }
2343                 if (info & DACL_SECURITY_INFORMATION) {
2344                         info &= ~DACL_SECURITY_INFORMATION;
2345                         goto retry;
2346                 }
2347                 if (info & OWNER_SECURITY_INFORMATION) {
2348                         info &= ~OWNER_SECURITY_INFORMATION;
2349                         goto retry;
2350                 }
2351                 /* Nothing left except GROUP, and if we removed it we
2352                  * wouldn't have anything at all.  */
2353         }
2354
2355         /* No part of the security descriptor could be set, or
2356          * WIMLIB_EXTRACT_FLAG_STRICT_ACLS is enabled and the full security
2357          * descriptor could not be set.  */
2358         if (!(info & SACL_SECURITY_INFORMATION))
2359                 ctx->partial_security_descriptors--;
2360         ctx->no_security_descriptors++;
2361
2362 out_maybe_free_desc:
2363         if (unlikely(desc_size > STACK_MAX))
2364                 FREE(desc);
2365         return status;
2366 }
2367
2368 /* Set metadata on the open file @h from the WIM inode @inode.  */
2369 static int
2370 do_apply_metadata_to_file(HANDLE h, const struct wim_inode *inode,
2371                           struct win32_apply_ctx *ctx)
2372 {
2373         FILE_BASIC_INFORMATION info;
2374         NTSTATUS status;
2375
2376         /* Set security descriptor if present and not in NO_ACLS mode  */
2377         if (inode->i_security_id >= 0 &&
2378             !(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS))
2379         {
2380                 const struct wim_security_data *sd;
2381                 const void *desc;
2382                 size_t desc_size;
2383
2384                 sd = wim_get_current_security_data(ctx->common.wim);
2385                 desc = sd->descriptors[inode->i_security_id];
2386                 desc_size = sd->sizes[inode->i_security_id];
2387
2388                 status = set_security_descriptor(h, desc, desc_size, ctx);
2389                 if (!NT_SUCCESS(status) &&
2390                     (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS))
2391                 {
2392                         set_errno_from_nt_status(status);
2393                         ERROR_WITH_ERRNO("Can't set security descriptor "
2394                                          "on \"%ls\" (status=0x%08"PRIx32")",
2395                                          current_path(ctx), (u32)status);
2396                         return WIMLIB_ERR_SET_SECURITY;
2397                 }
2398         }
2399
2400         /* Set attributes and timestamps  */
2401         info.CreationTime.QuadPart = inode->i_creation_time;
2402         info.LastAccessTime.QuadPart = inode->i_last_access_time;
2403         info.LastWriteTime.QuadPart = inode->i_last_write_time;
2404         info.ChangeTime.QuadPart = 0;
2405         if (ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)
2406                 info.FileAttributes = 0;
2407         else
2408                 info.FileAttributes = inode->i_attributes & ~SPECIAL_ATTRIBUTES;
2409
2410         status = (*func_NtSetInformationFile)(h, &ctx->iosb,
2411                                               &info, sizeof(info),
2412                                               FileBasicInformation);
2413         /* On FAT volumes we get STATUS_INVALID_PARAMETER if we try to set
2414          * attributes on the root directory.  (Apparently because FAT doesn't
2415          * actually have a place to store those attributes!)  */
2416         if (!NT_SUCCESS(status)
2417             && !(status == STATUS_INVALID_PARAMETER &&
2418                  dentry_is_root(inode_first_extraction_dentry(inode))))
2419         {
2420                 set_errno_from_nt_status(status);
2421                 ERROR_WITH_ERRNO("Can't set basic metadata on \"%ls\" "
2422                                  "(status=0x%08"PRIx32")",
2423                                  current_path(ctx), (u32)status);
2424                 return WIMLIB_ERR_SET_ATTRIBUTES;
2425         }
2426
2427         return 0;
2428 }
2429
2430 static int
2431 apply_metadata_to_file(const struct wim_dentry *dentry,
2432                        struct win32_apply_ctx *ctx)
2433 {
2434         const struct wim_inode *inode = dentry->d_inode;
2435         DWORD perms;
2436         HANDLE h;
2437         NTSTATUS status;
2438         int ret;
2439
2440         perms = FILE_WRITE_ATTRIBUTES | WRITE_DAC |
2441                 WRITE_OWNER | ACCESS_SYSTEM_SECURITY;
2442
2443         build_extraction_path(dentry, ctx);
2444
2445         /* Open a handle with as many relevant permissions as possible.  */
2446         while (!NT_SUCCESS(status = do_create_file(&h, perms, NULL,
2447                                                    0, FILE_OPEN, 0, ctx)))
2448         {
2449                 if (status == STATUS_PRIVILEGE_NOT_HELD ||
2450                     status == STATUS_ACCESS_DENIED)
2451                 {
2452                         if (perms & ACCESS_SYSTEM_SECURITY) {
2453                                 perms &= ~ACCESS_SYSTEM_SECURITY;
2454                                 continue;
2455                         }
2456                         if (perms & WRITE_DAC) {
2457                                 perms &= ~WRITE_DAC;
2458                                 continue;
2459                         }
2460                         if (perms & WRITE_OWNER) {
2461                                 perms &= ~WRITE_OWNER;
2462                                 continue;
2463                         }
2464                 }
2465                 set_errno_from_nt_status(status);
2466                 ERROR_WITH_ERRNO("Can't open \"%ls\" to set metadata "
2467                                  "(status=0x%08"PRIx32")",
2468                                  current_path(ctx), (u32)status);
2469                 return WIMLIB_ERR_OPEN;
2470         }
2471
2472         ret = do_apply_metadata_to_file(h, inode, ctx);
2473
2474         (*func_NtClose)(h);
2475
2476         return ret;
2477 }
2478
2479 static int
2480 apply_metadata(struct list_head *dentry_list, struct win32_apply_ctx *ctx)
2481 {
2482         const struct wim_dentry *dentry;
2483         int ret;
2484
2485         /* We go in reverse so that metadata is set on all a directory's
2486          * children before the directory itself.  This avoids any potential
2487          * problems with attributes, timestamps, or security descriptors.  */
2488         list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node)
2489         {
2490                 ret = apply_metadata_to_file(dentry, ctx);
2491                 ret = check_apply_error(dentry, ctx, ret);
2492                 if (ret)
2493                         return ret;
2494                 ret = report_file_metadata_applied(&ctx->common);
2495                 if (ret)
2496                         return ret;
2497         }
2498         return 0;
2499 }
2500
2501 /* Issue warnings about problems during the extraction for which warnings were
2502  * not already issued (due to the high number of potential warnings if we issued
2503  * them per-file).  */
2504 static void
2505 do_warnings(const struct win32_apply_ctx *ctx)
2506 {
2507         if (ctx->partial_security_descriptors == 0
2508             && ctx->no_security_descriptors == 0
2509             && ctx->num_set_short_name_failures == 0
2510         #if 0
2511             && ctx->num_remove_short_name_failures == 0
2512         #endif
2513             )
2514                 return;
2515
2516         WARNING("Extraction to \"%ls\" complete, but with one or more warnings:",
2517                 ctx->common.target);
2518         if (ctx->num_set_short_name_failures) {
2519                 WARNING("- Could not set short names on %lu files or directories",
2520                         ctx->num_set_short_name_failures);
2521         }
2522 #if 0
2523         if (ctx->num_remove_short_name_failures) {
2524                 WARNING("- Could not remove short names on %lu files or directories"
2525                         "          (This is expected on Vista and earlier)",
2526                         ctx->num_remove_short_name_failures);
2527         }
2528 #endif
2529         if (ctx->partial_security_descriptors) {
2530                 WARNING("- Could only partially set the security descriptor\n"
2531                         "            on %lu files or directories.",
2532                         ctx->partial_security_descriptors);
2533         }
2534         if (ctx->no_security_descriptors) {
2535                 WARNING("- Could not set security descriptor at all\n"
2536                         "            on %lu files or directories.",
2537                         ctx->no_security_descriptors);
2538         }
2539         if (ctx->partial_security_descriptors || ctx->no_security_descriptors) {
2540                 WARNING("To fully restore all security descriptors, run the program\n"
2541                         "          with Administrator rights.");
2542         }
2543 }
2544
2545 static uint64_t
2546 count_dentries(const struct list_head *dentry_list)
2547 {
2548         const struct list_head *cur;
2549         uint64_t count = 0;
2550
2551         list_for_each(cur, dentry_list)
2552                 count++;
2553
2554         return count;
2555 }
2556
2557 /* Extract files from a WIM image to a directory on Windows  */
2558 static int
2559 win32_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
2560 {
2561         int ret;
2562         struct win32_apply_ctx *ctx = (struct win32_apply_ctx *)_ctx;
2563         uint64_t dentry_count;
2564
2565         ret = prepare_target(dentry_list, ctx);
2566         if (ret)
2567                 goto out;
2568
2569         if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) {
2570                 ret = start_wimboot_extraction(ctx);
2571                 if (ret)
2572                         goto out;
2573         }
2574
2575         dentry_count = count_dentries(dentry_list);
2576
2577         ret = start_file_structure_phase(&ctx->common, dentry_count);
2578         if (ret)
2579                 goto out;
2580
2581         ret = create_directories(dentry_list, ctx);
2582         if (ret)
2583                 goto out;
2584
2585         ret = create_nondirectories(dentry_list, ctx);
2586         if (ret)
2587                 goto out;
2588
2589         ret = end_file_structure_phase(&ctx->common);
2590         if (ret)
2591                 goto out;
2592
2593         struct read_stream_list_callbacks cbs = {
2594                 .begin_stream      = begin_extract_stream,
2595                 .begin_stream_ctx  = ctx,
2596                 .consume_chunk     = extract_chunk,
2597                 .consume_chunk_ctx = ctx,
2598                 .end_stream        = end_extract_stream,
2599                 .end_stream_ctx    = ctx,
2600         };
2601         ret = extract_stream_list(&ctx->common, &cbs);
2602         if (ret)
2603                 goto out;
2604
2605         ret = start_file_metadata_phase(&ctx->common, dentry_count);
2606         if (ret)
2607                 goto out;
2608
2609         ret = apply_metadata(dentry_list, ctx);
2610         if (ret)
2611                 goto out;
2612
2613         ret = end_file_metadata_phase(&ctx->common);
2614         if (ret)
2615                 goto out;
2616
2617         if (unlikely(ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT)) {
2618                 ret = end_wimboot_extraction(ctx);
2619                 if (ret)
2620                         goto out;
2621         }
2622
2623         do_warnings(ctx);
2624 out:
2625         if (ctx->h_target)
2626                 (*func_NtClose)(ctx->h_target);
2627         if (ctx->target_ntpath.Buffer)
2628                 HeapFree(GetProcessHeap(), 0, ctx->target_ntpath.Buffer);
2629         FREE(ctx->pathbuf.Buffer);
2630         FREE(ctx->print_buffer);
2631         if (ctx->wimboot.prepopulate_pats) {
2632                 FREE(ctx->wimboot.prepopulate_pats->strings);
2633                 FREE(ctx->wimboot.prepopulate_pats);
2634         }
2635         FREE(ctx->wimboot.mem_prepopulate_pats);
2636         FREE(ctx->data_buffer);
2637         return ret;
2638 }
2639
2640 const struct apply_operations win32_apply_ops = {
2641         .name                   = "Windows",
2642         .get_supported_features = win32_get_supported_features,
2643         .extract                = win32_extract,
2644         .will_externally_back   = win32_will_externally_back,
2645         .context_size           = sizeof(struct win32_apply_ctx),
2646 };
2647
2648 #endif /* __WIN32__ */