66ca89a90804c4b7e08ffbd0cabfb5d415523e4c
[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 Eric Biggers
7  *
8  * This file is part of wimlib, a library for working with WIM files.
9  *
10  * wimlib is free software; you can redistribute it and/or modify it under the
11  * terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 3 of the License, or (at your option)
13  * any later version.
14  *
15  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
16  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
17  * A PARTICULAR PURPOSE. See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with wimlib; if not, see http://www.gnu.org/licenses/.
22  */
23
24 #ifdef __WIN32__
25
26 #include <aclapi.h> /* for SetSecurityInfo() */
27
28 #include "win32_common.h"
29 #include "wimlib_internal.h"
30 #include "dentry.h"
31 #include "lookup_table.h"
32 #include "endianness.h"
33
34 #define MAX_CREATE_HARD_LINK_WARNINGS 5
35 #define MAX_CREATE_SOFT_LINK_WARNINGS 5
36
37 #define MAX_SET_SD_ACCESS_DENIED_WARNINGS 1
38 #define MAX_SET_SACL_PRIV_NOTHELD_WARNINGS 1
39
40 static const wchar_t *apply_access_denied_msg =
41 L"If you are not running this program as the administrator, you may\n"
42  "          need to do so, so that all data and metadata can be extracted\n"
43  "          exactly as the origignal copy.  However, if you do not care that\n"
44  "          the security descriptors are extracted correctly, you could run\n"
45  "          `wimlib-imagex apply' with the --no-acls flag instead.\n"
46  ;
47
48
49 static int
50 win32_extract_try_rpfix(u8 *rpbuf,
51                         const wchar_t *extract_root_realpath,
52                         unsigned extract_root_realpath_nchars)
53 {
54         struct reparse_data rpdata;
55         wchar_t *target;
56         size_t target_nchars;
57         size_t stripped_nchars;
58         wchar_t *stripped_target;
59         wchar_t stripped_target_nchars;
60         int ret;
61
62         utf16lechar *new_target;
63         utf16lechar *new_print_name;
64         size_t new_target_nchars;
65         size_t new_print_name_nchars;
66         utf16lechar *p;
67
68         ret = parse_reparse_data(rpbuf, 8 + le16_to_cpu(*(u16*)(rpbuf + 4)),
69                                  &rpdata);
70         if (ret)
71                 return ret;
72
73         if (extract_root_realpath[0] == L'\0' ||
74             extract_root_realpath[1] != L':' ||
75             extract_root_realpath[2] != L'\\')
76         {
77                 ERROR("Can't understand full path format \"%ls\".  "
78                       "Try turning reparse point fixups off...",
79                       extract_root_realpath);
80                 return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED;
81         }
82
83         ret = parse_substitute_name(rpdata.substitute_name,
84                                     rpdata.substitute_name_nbytes,
85                                     rpdata.rptag);
86         if (ret < 0)
87                 return 0;
88         stripped_nchars = ret;
89         target = rpdata.substitute_name;
90         target_nchars = rpdata.substitute_name_nbytes / sizeof(utf16lechar);
91         stripped_target = target + 6;
92         stripped_target_nchars = target_nchars - stripped_nchars;
93
94         new_target = alloca((6 + extract_root_realpath_nchars +
95                              stripped_target_nchars) * sizeof(utf16lechar));
96
97         p = new_target;
98         if (stripped_nchars == 6) {
99                 /* Include \??\ prefix if it was present before */
100                 wmemcpy(p, L"\\??\\", 4);
101                 p += 4;
102         }
103
104         /* Print name excludes the \??\ if present. */
105         new_print_name = p;
106         if (stripped_nchars != 0) {
107                 /* Get drive letter from real path to extract root, if a drive
108                  * letter was present before. */
109                 *p++ = extract_root_realpath[0];
110                 *p++ = extract_root_realpath[1];
111         }
112         /* Copy the rest of the extract root */
113         wmemcpy(p, extract_root_realpath + 2, extract_root_realpath_nchars - 2);
114         p += extract_root_realpath_nchars - 2;
115
116         /* Append the stripped target */
117         wmemcpy(p, stripped_target, stripped_target_nchars);
118         p += stripped_target_nchars;
119         new_target_nchars = p - new_target;
120         new_print_name_nchars = p - new_print_name;
121
122         if (new_target_nchars * sizeof(utf16lechar) >= REPARSE_POINT_MAX_SIZE ||
123             new_print_name_nchars * sizeof(utf16lechar) >= REPARSE_POINT_MAX_SIZE)
124         {
125                 ERROR("Path names too long to do reparse point fixup!");
126                 return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED;
127         }
128         rpdata.substitute_name = new_target;
129         rpdata.substitute_name_nbytes = new_target_nchars * sizeof(utf16lechar);
130         rpdata.print_name = new_print_name;
131         rpdata.print_name_nbytes = new_print_name_nchars * sizeof(utf16lechar);
132         return make_reparse_buffer(&rpdata, rpbuf);
133 }
134
135 /* Wrapper around the FSCTL_SET_REPARSE_POINT ioctl to set the reparse data on
136  * an extracted reparse point. */
137 static int
138 win32_set_reparse_data(HANDLE h,
139                        const struct wim_inode *inode,
140                        const struct wim_lookup_table_entry *lte,
141                        const wchar_t *path,
142                        struct apply_args *args)
143 {
144         int ret;
145         u8 rpbuf[REPARSE_POINT_MAX_SIZE];
146         DWORD bytesReturned;
147
148         DEBUG("Setting reparse data on \"%ls\"", path);
149
150         ret = wim_inode_get_reparse_data(inode, rpbuf);
151         if (ret)
152                 return ret;
153
154         if (args->extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX &&
155             (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
156              inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT) &&
157             !inode->i_not_rpfixed)
158         {
159                 ret = win32_extract_try_rpfix(rpbuf,
160                                               args->target_realpath,
161                                               args->target_realpath_len);
162                 if (ret)
163                         return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED;
164         }
165
166         /* Set the reparse data on the open file using the
167          * FSCTL_SET_REPARSE_POINT ioctl.
168          *
169          * There are contradictions in Microsoft's documentation for this:
170          *
171          * "If hDevice was opened without specifying FILE_FLAG_OVERLAPPED,
172          * lpOverlapped is ignored."
173          *
174          * --- So setting lpOverlapped to NULL is okay since it's ignored.
175          *
176          * "If lpOverlapped is NULL, lpBytesReturned cannot be NULL. Even when an
177          * operation returns no output data and lpOutBuffer is NULL,
178          * DeviceIoControl makes use of lpBytesReturned. After such an
179          * operation, the value of lpBytesReturned is meaningless."
180          *
181          * --- So lpOverlapped not really ignored, as it affects another
182          *  parameter.  This is the actual behavior: lpBytesReturned must be
183          *  specified, even though lpBytesReturned is documented as:
184          *
185          *  "Not used with this operation; set to NULL."
186          */
187         if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, rpbuf,
188                              8 + le16_to_cpu(*(u16*)(rpbuf + 4)),
189                              NULL, 0,
190                              &bytesReturned /* lpBytesReturned */,
191                              NULL /* lpOverlapped */))
192         {
193                 DWORD err = GetLastError();
194                 if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD)
195                 {
196                         args->num_soft_links_failed++;
197                         if (args->num_soft_links_failed <= MAX_CREATE_SOFT_LINK_WARNINGS) {
198                                 WARNING("Can't set reparse data on \"%ls\": Access denied!\n"
199                                         "          You may be trying to extract a symbolic "
200                                         "link without the\n"
201                                         "          SeCreateSymbolicLink privilege, which by "
202                                         "default non-Administrator\n"
203                                         "          accounts do not have.", path);
204                         }
205                         if (args->num_hard_links_failed == MAX_CREATE_HARD_LINK_WARNINGS) {
206                                 WARNING("Suppressing further warnings regarding failure to extract\n"
207                                         "          reparse points due to insufficient privileges...");
208                         }
209                 } else {
210                         ERROR("Failed to set reparse data on \"%ls\"", path);
211                         win32_error(err);
212                         if (inode->i_reparse_tag == WIM_IO_REPARSE_TAG_SYMLINK ||
213                             inode->i_reparse_tag == WIM_IO_REPARSE_TAG_MOUNT_POINT)
214                                 return WIMLIB_ERR_LINK;
215                         else
216                                 return WIMLIB_ERR_WRITE;
217                 }
218         }
219         return 0;
220 }
221
222 /* Wrapper around the FSCTL_SET_COMPRESSION ioctl to change the
223  * FILE_ATTRIBUTE_COMPRESSED flag of a file or directory. */
224 static int
225 win32_set_compression_state(HANDLE hFile, USHORT format, const wchar_t *path)
226 {
227         DWORD bytesReturned;
228         if (!DeviceIoControl(hFile, FSCTL_SET_COMPRESSION,
229                              &format, sizeof(USHORT),
230                              NULL, 0,
231                              &bytesReturned, NULL))
232         {
233                 /* Could be a warning only, but we only call this if the volume
234                  * supports compression.  So I'm calling this an error. */
235                 DWORD err = GetLastError();
236                 ERROR("Failed to set compression flag on \"%ls\"", path);
237                 win32_error(err);
238                 if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD)
239                         return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES_TO_EXTRACT;
240                 else
241                         return WIMLIB_ERR_WRITE;
242         }
243         return 0;
244 }
245
246 /* Wrapper around FSCTL_SET_SPARSE ioctl to set a file as sparse. */
247 static int
248 win32_set_sparse(HANDLE hFile, const wchar_t *path)
249 {
250         DWORD bytesReturned;
251         if (!DeviceIoControl(hFile, FSCTL_SET_SPARSE,
252                              NULL, 0,
253                              NULL, 0,
254                              &bytesReturned, NULL))
255         {
256                 /* Could be a warning only, but we only call this if the volume
257                  * supports sparse files.  So I'm calling this an error. */
258                 DWORD err = GetLastError();
259                 WARNING("Failed to set sparse flag on \"%ls\"", path);
260                 win32_error(err);
261                 if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD)
262                         return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES_TO_EXTRACT;
263                 else
264                         return WIMLIB_ERR_WRITE;
265         }
266         return 0;
267 }
268
269 /*
270  * Sets the security descriptor on an extracted file.
271  */
272 static int
273 win32_set_security_data(const struct wim_inode *inode,
274                         HANDLE hFile,
275                         const wchar_t *path,
276                         struct apply_args *args)
277 {
278         PSECURITY_DESCRIPTOR descriptor;
279         unsigned long n;
280         DWORD err;
281         const struct wim_security_data *sd;
282
283         SECURITY_INFORMATION securityInformation = 0;
284
285         void *owner = NULL;
286         void *group = NULL;
287         ACL *dacl = NULL;
288         ACL *sacl = NULL;
289
290         BOOL owner_defaulted;
291         BOOL group_defaulted;
292         BOOL dacl_present;
293         BOOL dacl_defaulted;
294         BOOL sacl_present;
295         BOOL sacl_defaulted;
296
297         sd = wim_const_security_data(args->w);
298         descriptor = sd->descriptors[inode->i_security_id];
299
300         GetSecurityDescriptorOwner(descriptor, &owner, &owner_defaulted);
301         if (owner)
302                 securityInformation |= OWNER_SECURITY_INFORMATION;
303
304         GetSecurityDescriptorGroup(descriptor, &group, &group_defaulted);
305         if (group)
306                 securityInformation |= GROUP_SECURITY_INFORMATION;
307
308         GetSecurityDescriptorDacl(descriptor, &dacl_present,
309                                   &dacl, &dacl_defaulted);
310         if (dacl)
311                 securityInformation |= DACL_SECURITY_INFORMATION;
312
313         GetSecurityDescriptorSacl(descriptor, &sacl_present,
314                                   &sacl, &sacl_defaulted);
315         if (sacl)
316                 securityInformation |= SACL_SECURITY_INFORMATION;
317
318 again:
319         if (securityInformation == 0)
320                 return 0;
321         if (SetSecurityInfo(hFile, SE_FILE_OBJECT,
322                             securityInformation, owner, group, dacl, sacl))
323                 return 0;
324         err = GetLastError();
325         if (args->extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
326                 goto fail;
327         switch (err) {
328         case ERROR_PRIVILEGE_NOT_HELD:
329                 if (securityInformation & SACL_SECURITY_INFORMATION) {
330                         n = args->num_set_sacl_priv_notheld++;
331                         securityInformation &= ~SACL_SECURITY_INFORMATION;
332                         sacl = NULL;
333                         if (n < MAX_SET_SACL_PRIV_NOTHELD_WARNINGS) {
334                                 WARNING(
335 "We don't have enough privileges to set the full security\n"
336 "          descriptor on \"%ls\"!\n", path);
337                                 if (args->num_set_sd_access_denied +
338                                     args->num_set_sacl_priv_notheld == 1)
339                                 {
340                                         WARNING("%ls", apply_access_denied_msg);
341                                 }
342                                 WARNING("Re-trying with SACL omitted.\n", path);
343                         } else if (n == MAX_SET_SACL_PRIV_NOTHELD_WARNINGS) {
344                                 WARNING(
345 "Suppressing further 'privileges not held' error messages when setting\n"
346 "          security descriptors.");
347                         }
348                         goto again;
349                 }
350                 /* Fall through */
351         case ERROR_INVALID_OWNER:
352         case ERROR_ACCESS_DENIED:
353                 n = args->num_set_sd_access_denied++;
354                 if (n < MAX_SET_SD_ACCESS_DENIED_WARNINGS) {
355                         WARNING("Failed to set security descriptor on \"%ls\": "
356                                 "Access denied!\n", path);
357                         if (args->num_set_sd_access_denied +
358                             args->num_set_sacl_priv_notheld == 1)
359                         {
360                                 WARNING("%ls", apply_access_denied_msg);
361                         }
362                 } else if (n == MAX_SET_SD_ACCESS_DENIED_WARNINGS) {
363                         WARNING(
364 "Suppressing further access denied error messages when setting\n"
365 "          security descriptors");
366                 }
367                 return 0;
368         default:
369 fail:
370                 ERROR("Failed to set security descriptor on \"%ls\"", path);
371                 win32_error(err);
372                 if (err == ERROR_ACCESS_DENIED || err == ERROR_PRIVILEGE_NOT_HELD)
373                         return WIMLIB_ERR_INSUFFICIENT_PRIVILEGES_TO_EXTRACT;
374                 else
375                         return WIMLIB_ERR_WRITE;
376         }
377 }
378
379
380 static int
381 win32_extract_chunk(const void *buf, size_t len, void *arg)
382 {
383         HANDLE hStream = arg;
384
385         DWORD nbytes_written;
386         wimlib_assert(len <= 0xffffffff);
387
388         if (!WriteFile(hStream, buf, len, &nbytes_written, NULL) ||
389             nbytes_written != len)
390         {
391                 DWORD err = GetLastError();
392                 ERROR("WriteFile(): write error");
393                 win32_error(err);
394                 return WIMLIB_ERR_WRITE;
395         }
396         return 0;
397 }
398
399 static int
400 do_win32_extract_stream(HANDLE hStream, const struct wim_lookup_table_entry *lte)
401 {
402         return extract_wim_resource(lte, wim_resource_size(lte),
403                                     win32_extract_chunk, hStream);
404 }
405
406 struct win32_encrypted_extract_ctx {
407         const struct wim_lookup_table_entry *lte;
408         u64 offset;
409 };
410
411 static DWORD WINAPI
412 win32_encrypted_import_cb(unsigned char *data, void *_ctx,
413                           unsigned long *len_p)
414 {
415         struct win32_encrypted_extract_ctx *ctx = _ctx;
416         unsigned long len = *len_p;
417         const struct wim_lookup_table_entry *lte = ctx->lte;
418
419         len = min(len, wim_resource_size(lte) - ctx->offset);
420
421         if (read_partial_wim_resource_into_buf(lte, len, ctx->offset, data))
422                 return ERROR_READ_FAULT;
423
424         ctx->offset += len;
425         *len_p = len;
426         return ERROR_SUCCESS;
427 }
428
429 /* Create an encrypted file and extract the raw encrypted data to it.
430  *
431  * @path:  Path to encrypted file to create.
432  * @lte:   WIM lookup_table entry for the raw encrypted data.
433  *
434  * This is separate from do_win32_extract_stream() because the WIM is supposed
435  * to contain the *raw* encrypted data, which needs to be extracted ("imported")
436  * using the special APIs OpenEncryptedFileRawW(), WriteEncryptedFileRaw(), and
437  * CloseEncryptedFileRaw().
438  *
439  * Returns 0 on success; nonzero on failure.
440  */
441 static int
442 do_win32_extract_encrypted_stream(const wchar_t *path,
443                                   const struct wim_lookup_table_entry *lte)
444 {
445         void *file_ctx;
446         int ret;
447
448         DEBUG("Opening file \"%ls\" to extract raw encrypted data", path);
449
450         ret = OpenEncryptedFileRawW(path, CREATE_FOR_IMPORT, &file_ctx);
451         if (ret) {
452                 ERROR("Failed to open \"%ls\" to write raw encrypted data", path);
453                 win32_error(ret);
454                 return WIMLIB_ERR_OPEN;
455         }
456
457         if (lte) {
458                 struct win32_encrypted_extract_ctx ctx;
459
460                 ctx.lte = lte;
461                 ctx.offset = 0;
462                 ret = WriteEncryptedFileRaw(win32_encrypted_import_cb, &ctx, file_ctx);
463                 if (ret == ERROR_SUCCESS) {
464                         ret = 0;
465                 } else {
466                         ret = WIMLIB_ERR_WRITE;
467                         ERROR("Failed to extract encrypted file \"%ls\"", path);
468                 }
469         }
470         CloseEncryptedFileRaw(file_ctx);
471         return ret;
472 }
473
474 static bool
475 path_is_root_of_drive(const wchar_t *path)
476 {
477         if (!*path)
478                 return false;
479
480         if (*path != L'/' && *path != L'\\') {
481                 if (*(path + 1) == L':')
482                         path += 2;
483                 else
484                         return false;
485         }
486         while (*path == L'/' || *path == L'\\')
487                 path++;
488         return (*path == L'\0');
489 }
490
491 static inline DWORD
492 win32_mask_attributes(DWORD i_attributes)
493 {
494         return i_attributes & ~(FILE_ATTRIBUTE_SPARSE_FILE |
495                                 FILE_ATTRIBUTE_COMPRESSED |
496                                 FILE_ATTRIBUTE_REPARSE_POINT |
497                                 FILE_ATTRIBUTE_DIRECTORY |
498                                 FILE_ATTRIBUTE_ENCRYPTED |
499                                 FILE_FLAG_DELETE_ON_CLOSE |
500                                 FILE_FLAG_NO_BUFFERING |
501                                 FILE_FLAG_OPEN_NO_RECALL |
502                                 FILE_FLAG_OVERLAPPED |
503                                 FILE_FLAG_RANDOM_ACCESS |
504                                 /*FILE_FLAG_SESSION_AWARE |*/
505                                 FILE_FLAG_SEQUENTIAL_SCAN |
506                                 FILE_FLAG_WRITE_THROUGH);
507 }
508
509 static inline DWORD
510 win32_get_create_flags_and_attributes(DWORD i_attributes)
511 {
512         /*
513          * Some attributes cannot be set by passing them to CreateFile().  In
514          * particular:
515          *
516          * FILE_ATTRIBUTE_DIRECTORY:
517          *   CreateDirectory() must be called instead of CreateFile().
518          *
519          * FILE_ATTRIBUTE_SPARSE_FILE:
520          *   Needs an ioctl.
521          *   See: win32_set_sparse().
522          *
523          * FILE_ATTRIBUTE_COMPRESSED:
524          *   Not clear from the documentation, but apparently this needs an
525          *   ioctl as well.
526          *   See: win32_set_compressed().
527          *
528          * FILE_ATTRIBUTE_REPARSE_POINT:
529          *   Needs an ioctl, with the reparse data specified.
530          *   See: win32_set_reparse_data().
531          *
532          * In addition, clear any file flags in the attributes that we don't
533          * want, but also specify FILE_FLAG_OPEN_REPARSE_POINT and
534          * FILE_FLAG_BACKUP_SEMANTICS as we are a backup application.
535          */
536         return win32_mask_attributes(i_attributes) |
537                 FILE_FLAG_OPEN_REPARSE_POINT |
538                 FILE_FLAG_BACKUP_SEMANTICS;
539 }
540
541 /* Set compression and/or sparse attributes on a stream, if supported by the
542  * volume. */
543 static int
544 win32_set_special_stream_attributes(HANDLE hFile, const struct wim_inode *inode,
545                                     struct wim_lookup_table_entry *unnamed_stream_lte,
546                                     const wchar_t *path, unsigned vol_flags)
547 {
548         int ret;
549
550         if (inode->i_attributes & FILE_ATTRIBUTE_COMPRESSED) {
551                 if (vol_flags & FILE_FILE_COMPRESSION) {
552                         ret = win32_set_compression_state(hFile,
553                                                           COMPRESSION_FORMAT_DEFAULT,
554                                                           path);
555                         if (ret)
556                                 return ret;
557                 } else {
558                         DEBUG("Cannot set compression attribute on \"%ls\": "
559                               "volume does not support transparent compression",
560                               path);
561                 }
562         }
563
564         if (inode->i_attributes & FILE_ATTRIBUTE_SPARSE_FILE) {
565                 if (vol_flags & FILE_SUPPORTS_SPARSE_FILES) {
566                         DEBUG("Setting sparse flag on \"%ls\"", path);
567                         ret = win32_set_sparse(hFile, path);
568                         if (ret)
569                                 return ret;
570                 } else {
571                         DEBUG("Cannot set sparse attribute on \"%ls\": "
572                               "volume does not support sparse files",
573                               path);
574                 }
575         }
576         return 0;
577 }
578
579 /* Pre-create directories; extract encrypted streams */
580 static int
581 win32_begin_extract_unnamed_stream(const struct wim_inode *inode,
582                                    const struct wim_lookup_table_entry *lte,
583                                    const wchar_t *path,
584                                    DWORD *creationDisposition_ret,
585                                    unsigned int vol_flags)
586 {
587         DWORD err;
588         int ret;
589
590         /* Directories must be created with CreateDirectoryW().  Then the call
591          * to CreateFileW() will merely open the directory that was already
592          * created rather than creating a new file. */
593         if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY &&
594             !path_is_root_of_drive(path)) {
595                 if (!CreateDirectoryW(path, NULL)) {
596                         err = GetLastError();
597                         if (err != ERROR_ALREADY_EXISTS) {
598                                 ERROR("Failed to create directory \"%ls\"",
599                                       path);
600                                 win32_error(err);
601                                 return WIMLIB_ERR_MKDIR;
602                         }
603                 }
604                 DEBUG("Created directory \"%ls\"", path);
605                 *creationDisposition_ret = OPEN_EXISTING;
606         }
607         if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED &&
608             vol_flags & FILE_SUPPORTS_ENCRYPTION)
609         {
610                 if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
611                         unsigned remaining_sharing_violations = 100;
612                         while (!EncryptFile(path)) {
613                                 if (remaining_sharing_violations &&
614                                     err == ERROR_SHARING_VIOLATION)
615                                 {
616                                         WARNING("Couldn't encrypt directory \"%ls\" "
617                                                 "due to sharing violation; re-trying "
618                                                 "after 100 ms", path);
619                                         Sleep(100);
620                                         remaining_sharing_violations--;
621                                 } else {
622                                         err = GetLastError();
623                                         ERROR("Failed to encrypt directory \"%ls\"",
624                                               path);
625                                         win32_error(err);
626                                         return WIMLIB_ERR_WRITE;
627                                 }
628                         }
629                 } else {
630                         ret = do_win32_extract_encrypted_stream(path, lte);
631                         if (ret)
632                                 return ret;
633                         DEBUG("Extracted encrypted file \"%ls\"", path);
634                 }
635                 *creationDisposition_ret = OPEN_EXISTING;
636         }
637
638         /* Set file attributes if we created the file.  Otherwise, we haven't
639          * created the file set and we will set the attributes in the call to
640          * CreateFileW().
641          *
642          * The FAT filesystem does not let you change the attributes of the root
643          * directory, so treat that as a special case and do not set attributes.
644          * */
645         if (*creationDisposition_ret == OPEN_EXISTING &&
646             !path_is_root_of_drive(path))
647         {
648                 if (!SetFileAttributesW(path,
649                                         win32_mask_attributes(inode->i_attributes)))
650                 {
651                         err = GetLastError();
652                         ERROR("Failed to set attributes on \"%ls\"", path);
653                         win32_error(err);
654                         return WIMLIB_ERR_WRITE;
655                 }
656         }
657         return 0;
658 }
659
660 /* Set security descriptor and extract stream data or reparse data (skip the
661  * unnamed data stream of encrypted files, which was already extracted). */
662 static int
663 win32_finish_extract_stream(HANDLE h, const struct wim_dentry *dentry,
664                             const struct wim_lookup_table_entry *lte,
665                             const wchar_t *stream_path,
666                             const wchar_t *stream_name_utf16,
667                             struct apply_args *args)
668 {
669         int ret = 0;
670         const struct wim_inode *inode = dentry->d_inode;
671         const wchar_t *short_name;
672         if (stream_name_utf16 == NULL) {
673                 /* Unnamed stream. */
674
675                 /* Set security descriptor, unless the extract_flags indicate
676                  * not to or the volume does not supported it.  Note that this
677                  * is only done when the unnamed stream is being extracted, as
678                  * security descriptors are per-file and not per-stream. */
679                 if (inode->i_security_id >= 0 &&
680                     !(args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS)
681                     && (args->vol_flags & FILE_PERSISTENT_ACLS))
682                 {
683                         ret = win32_set_security_data(inode, h, stream_path, args);
684                         if (ret)
685                                 return ret;
686                 }
687
688                 /* Handle reparse points.  The data for them needs to be set
689                  * using a special ioctl.  Note that the reparse point may have
690                  * been created using CreateFileW() in the case of
691                  * non-directories or CreateDirectoryW() in the case of
692                  * directories; but the ioctl works either way.  Also, it is
693                  * only this step that actually sets the
694                  * FILE_ATTRIBUTE_REPARSE_POINT, as it is not valid to set it
695                  * using SetFileAttributesW() or CreateFileW().
696                  *
697                  * If the volume does not support reparse points we simply
698                  * ignore the reparse data.  (N.B. the code currently doesn't
699                  * actually reach this case because reparse points are skipped
700                  * entirely on such volumes.) */
701                 if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
702                         if (args->vol_flags & FILE_SUPPORTS_REPARSE_POINTS) {
703                                 ret = win32_set_reparse_data(h, inode,
704                                                              lte, stream_path,
705                                                              args);
706                                 if (ret)
707                                         return ret;
708                         } else {
709                                 DEBUG("Cannot set reparse data on \"%ls\": volume "
710                                       "does not support reparse points", stream_path);
711                         }
712                 } else if (lte != NULL &&
713                            !(args->vol_flags & FILE_SUPPORTS_ENCRYPTION &&
714                              inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED))
715                 {
716                         /* Extract the data of the unnamed stream, unless the
717                          * lookup table entry is NULL (indicating an empty
718                          * stream for which no data needs to be extracted), or
719                          * the stream is encrypted and therefore was already
720                          * extracted as a special case. */
721                         ret = do_win32_extract_stream(h, lte);
722                         if (ret)
723                                 return ret;
724                 }
725
726                 if (dentry_has_short_name(dentry))
727                         short_name = dentry->short_name;
728                 else
729                         short_name = L"";
730                 /* Set short name */
731                 if (!SetFileShortNameW(h, short_name)) {
732                 #if 0
733                         DWORD err = GetLastError();
734                         ERROR("Could not set short name on \"%ls\"", stream_path);
735                         win32_error(err);
736                 #endif
737                 }
738         } else {
739                 /* Extract the data for a named data stream. */
740                 if (lte != NULL) {
741                         DEBUG("Extracting named data stream \"%ls\" (len = %"PRIu64")",
742                               stream_path, wim_resource_size(lte));
743                         ret = do_win32_extract_stream(h, lte);
744                 }
745         }
746         return ret;
747 }
748
749 static int
750 win32_decrypt_file(HANDLE open_handle, const wchar_t *path)
751 {
752         DWORD err;
753         /* We cannot call DecryptFileW() while there is an open handle to the
754          * file.  So close it first. */
755         if (!CloseHandle(open_handle)) {
756                 err = GetLastError();
757                 ERROR("Failed to close handle for \"%ls\"", path);
758                 win32_error(err);
759                 return WIMLIB_ERR_WRITE;
760         }
761         if (!DecryptFileW(path, 0 /* reserved parameter; set to 0 */)) {
762                 err = GetLastError();
763                 ERROR("Failed to decrypt file \"%ls\"", path);
764                 win32_error(err);
765                 return WIMLIB_ERR_WRITE;
766         }
767         return 0;
768 }
769
770 /*
771  * Create and extract a stream to a file, or create a directory, using the
772  * Windows API.
773  *
774  * This handles reparse points, directories, alternate data streams, encrypted
775  * files, compressed files, etc.
776  *
777  * @dentry: WIM dentry for the file or directory being extracted.
778  *
779  * @path:  Path to extract the file to.
780  *
781  * @stream_name_utf16:
782  *         Name of the stream, or NULL if the stream is unnamed.  This will
783  *         be called with a NULL stream_name_utf16 before any non-NULL
784  *         stream_name_utf16's.
785  *
786  * @lte:   WIM lookup table entry for the stream.  May be NULL to indicate
787  *         a stream of length 0.
788  *
789  * @args:  Additional apply context, including flags indicating supported
790  *         volume features.
791  *
792  * Returns 0 on success; nonzero on failure.
793  */
794 static int
795 win32_extract_stream(const struct wim_dentry *dentry,
796                      const wchar_t *path,
797                      const wchar_t *stream_name_utf16,
798                      struct wim_lookup_table_entry *lte,
799                      struct apply_args *args)
800 {
801         wchar_t *stream_path;
802         HANDLE h;
803         int ret;
804         DWORD err;
805         DWORD creationDisposition = CREATE_ALWAYS;
806         DWORD requestedAccess;
807         BY_HANDLE_FILE_INFORMATION file_info;
808         unsigned remaining_sharing_violations = 1000;
809         const struct wim_inode *inode = dentry->d_inode;
810
811         if (stream_name_utf16) {
812                 /* Named stream.  Create a buffer that contains the UTF-16LE
813                  * string [./]path:stream_name_utf16.  This is needed to
814                  * create and open the stream using CreateFileW().  I'm not
815                  * aware of any other APIs to do this.  Note: the '$DATA' suffix
816                  * seems to be unneeded.  Additional note: a "./" prefix needs
817                  * to be added when the path is not absolute to avoid ambiguity
818                  * with drive letters. */
819                 size_t stream_path_nchars;
820                 size_t path_nchars;
821                 size_t stream_name_nchars;
822                 const wchar_t *prefix;
823
824                 path_nchars = wcslen(path);
825                 stream_name_nchars = wcslen(stream_name_utf16);
826                 stream_path_nchars = path_nchars + 1 + stream_name_nchars;
827                 if (path[0] != cpu_to_le16(L'\0') &&
828                     path[0] != cpu_to_le16(L'/') &&
829                     path[0] != cpu_to_le16(L'\\') &&
830                     path[1] != cpu_to_le16(L':'))
831                 {
832                         prefix = L"./";
833                         stream_path_nchars += 2;
834                 } else {
835                         prefix = L"";
836                 }
837                 stream_path = alloca((stream_path_nchars + 1) * sizeof(wchar_t));
838                 swprintf(stream_path, L"%ls%ls:%ls",
839                          prefix, path, stream_name_utf16);
840         } else {
841                 /* Unnamed stream; its path is just the path to the file itself.
842                  * */
843                 stream_path = (wchar_t*)path;
844
845                 ret = win32_begin_extract_unnamed_stream(inode, lte, path,
846                                                          &creationDisposition,
847                                                          args->vol_flags);
848                 if (ret)
849                         goto fail;
850         }
851
852         DEBUG("Opening \"%ls\"", stream_path);
853         /* DELETE access is needed for SetFileShortNameW(), for some reason. */
854         requestedAccess = GENERIC_READ | GENERIC_WRITE | DELETE |
855                           ACCESS_SYSTEM_SECURITY;
856 try_open_again:
857         /* Open the stream to be extracted.  Depending on what we have set
858          * creationDisposition to, we may be creating this for the first time,
859          * or we may be opening on existing stream we already created using
860          * CreateDirectoryW() or OpenEncryptedFileRawW(). */
861         h = CreateFileW(stream_path,
862                         requestedAccess,
863                         FILE_SHARE_READ,
864                         NULL,
865                         creationDisposition,
866                         win32_get_create_flags_and_attributes(inode->i_attributes),
867                         NULL);
868         if (h == INVALID_HANDLE_VALUE) {
869                 err = GetLastError();
870                 if (err == ERROR_ACCESS_DENIED &&
871                     path_is_root_of_drive(stream_path))
872                 {
873                         ret = 0;
874                         goto out;
875                 }
876                 if ((err == ERROR_PRIVILEGE_NOT_HELD ||
877                      err == ERROR_ACCESS_DENIED) &&
878                     (requestedAccess & ACCESS_SYSTEM_SECURITY))
879                 {
880                         /* Try opening the file again without privilege to
881                          * modify SACL. */
882                         requestedAccess &= ~ACCESS_SYSTEM_SECURITY;
883                         goto try_open_again;
884                 }
885                 if (err == ERROR_SHARING_VIOLATION) {
886                         if (remaining_sharing_violations) {
887                                 --remaining_sharing_violations;
888                                 /* This can happen when restoring encrypted directories
889                                  * for some reason.  Probably a bug in EncryptFile(). */
890                                 WARNING("Couldn't open \"%ls\" due to sharing violation; "
891                                         "re-trying after 100ms", stream_path);
892                                 Sleep(100);
893                                 goto try_open_again;
894                         } else {
895                                 ERROR("Too many sharing violations; giving up...");
896                         }
897                 } else {
898                         if (creationDisposition == OPEN_EXISTING)
899                                 ERROR("Failed to open \"%ls\"", stream_path);
900                         else
901                                 ERROR("Failed to create \"%ls\"", stream_path);
902                         win32_error(err);
903                 }
904                 ret = WIMLIB_ERR_OPEN;
905                 goto fail;
906         }
907
908         /* Check the attributes of the file we just opened, and remove
909          * encryption or compression if either was set by default but is not
910          * supposed to be set based on the WIM inode attributes. */
911         if (!GetFileInformationByHandle(h, &file_info)) {
912                 err = GetLastError();
913                 ERROR("Failed to get attributes of \"%ls\"", stream_path);
914                 win32_error(err);
915                 ret = WIMLIB_ERR_STAT;
916                 goto fail_close_handle;
917         }
918
919         /* Remove encryption? */
920         if (file_info.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED &&
921             !(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED))
922         {
923                 /* File defaulted to encrypted due to being in an encrypted
924                  * directory, but is not actually supposed to be encrypted.
925                  *
926                  * This is a workaround, because I'm not aware of any way to
927                  * directly (e.g. with CreateFileW()) create an unencrypted file
928                  * in a directory with FILE_ATTRIBUTE_ENCRYPTED set. */
929                 ret = win32_decrypt_file(h, stream_path);
930                 if (ret)
931                         goto fail; /* win32_decrypt_file() closed the handle. */
932                 creationDisposition = OPEN_EXISTING;
933                 goto try_open_again;
934         }
935
936         /* Remove compression? */
937         if (file_info.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED &&
938             !(inode->i_attributes & FILE_ATTRIBUTE_COMPRESSED))
939         {
940                 /* Similar to the encrypted case, above, if the file defaulted
941                  * to compressed due to being in an compressed directory, but is
942                  * not actually supposed to be compressed, explicitly set the
943                  * compression format to COMPRESSION_FORMAT_NONE. */
944                 ret = win32_set_compression_state(h, COMPRESSION_FORMAT_NONE,
945                                                   stream_path);
946                 if (ret)
947                         goto fail_close_handle;
948         }
949
950         /* Set compression and/or sparse attributes if needed */
951         ret = win32_set_special_stream_attributes(h, inode, lte, path,
952                                                   args->vol_flags);
953
954         if (ret)
955                 goto fail_close_handle;
956
957         /* At this point we have at least created the needed stream with the
958          * appropriate attributes.  We have yet to set the appropriate security
959          * descriptor and actually extract the stream data (other than for
960          * extracted files, which were already extracted).
961          * win32_finish_extract_stream() handles these additional steps. */
962         ret = win32_finish_extract_stream(h, dentry, lte, stream_path,
963                                           stream_name_utf16, args);
964         if (ret)
965                 goto fail_close_handle;
966
967         /* Done extracting the stream.  Close the handle and return. */
968         DEBUG("Closing \"%ls\"", stream_path);
969         if (!CloseHandle(h)) {
970                 err = GetLastError();
971                 ERROR("Failed to close \"%ls\"", stream_path);
972                 win32_error(err);
973                 ret = WIMLIB_ERR_WRITE;
974                 goto fail;
975         }
976         ret = 0;
977         goto out;
978 fail_close_handle:
979         CloseHandle(h);
980 fail:
981         ERROR("Error extracting \"%ls\"", stream_path);
982 out:
983         return ret;
984 }
985
986 /*
987  * Creates a file, directory, or reparse point and extracts all streams to it
988  * (unnamed data stream and/or reparse point stream, plus any alternate data
989  * streams).  Handles sparse, compressed, and/or encrypted files.
990  *
991  * @dentry:     WIM dentry for this file or directory.
992  * @path:       UTF-16LE external path to extract the inode to.
993  * @args:       Additional extraction context.
994  *
995  * Returns 0 on success; nonzero on failure.
996  */
997 static int
998 win32_extract_streams(const struct wim_dentry *dentry,
999                       const wchar_t *path, struct apply_args *args)
1000 {
1001         struct wim_lookup_table_entry *unnamed_lte;
1002         int ret;
1003         const struct wim_inode *inode = dentry->d_inode;
1004
1005         /* First extract the unnamed stream. */
1006
1007         unnamed_lte = inode_unnamed_lte_resolved(inode);
1008         ret = win32_extract_stream(dentry, path, NULL, unnamed_lte, args);
1009         if (ret)
1010                 goto out;
1011
1012         /* Extract any named streams, if supported by the volume. */
1013
1014         if (!(args->vol_flags & FILE_NAMED_STREAMS))
1015                 goto out;
1016         for (u16 i = 0; i < inode->i_num_ads; i++) {
1017                 const struct wim_ads_entry *ads_entry = &inode->i_ads_entries[i];
1018
1019                 /* Skip the unnamed stream if it's in the ADS entries (we
1020                  * already extracted it...) */
1021                 if (ads_entry->stream_name_nbytes == 0)
1022                         continue;
1023
1024                 /* Skip special UNIX data entries (see documentation for
1025                  * WIMLIB_ADD_FLAG_UNIX_DATA) */
1026                 if (ads_entry->stream_name_nbytes == WIMLIB_UNIX_DATA_TAG_UTF16LE_NBYTES
1027                     && !memcmp(ads_entry->stream_name,
1028                                WIMLIB_UNIX_DATA_TAG_UTF16LE,
1029                                WIMLIB_UNIX_DATA_TAG_UTF16LE_NBYTES))
1030                         continue;
1031
1032                 /* Extract the named stream */
1033                 ret = win32_extract_stream(dentry,
1034                                            path,
1035                                            ads_entry->stream_name,
1036                                            ads_entry->lte,
1037                                            args);
1038                 if (ret)
1039                         break;
1040         }
1041 out:
1042         return ret;
1043 }
1044
1045 /* If not done already, load the supported feature flags for the volume onto
1046  * which the image is being extracted, and warn the user about any missing
1047  * features that could be important. */
1048 static int
1049 win32_check_vol_flags(const wchar_t *output_path, struct apply_args *args)
1050 {
1051         if (args->have_vol_flags)
1052                 return 0;
1053
1054         win32_get_vol_flags(output_path, &args->vol_flags);
1055         args->have_vol_flags = true;
1056         /* Warn the user about data that may not be extracted. */
1057         if (!(args->vol_flags & FILE_SUPPORTS_SPARSE_FILES))
1058                 WARNING("Volume does not support sparse files!\n"
1059                         "          Sparse files will be extracted as non-sparse.");
1060         if (!(args->vol_flags & FILE_SUPPORTS_REPARSE_POINTS))
1061                 WARNING("Volume does not support reparse points!\n"
1062                         "          Reparse point data will not be extracted.");
1063         if (!(args->vol_flags & FILE_NAMED_STREAMS)) {
1064                 WARNING("Volume does not support named data streams!\n"
1065                         "          Named data streams will not be extracted.");
1066         }
1067         if (!(args->vol_flags & FILE_SUPPORTS_ENCRYPTION)) {
1068                 WARNING("Volume does not support encryption!\n"
1069                         "          Encrypted files will be extracted as raw data.");
1070         }
1071         if (!(args->vol_flags & FILE_FILE_COMPRESSION)) {
1072                 WARNING("Volume does not support transparent compression!\n"
1073                         "          Compressed files will be extracted as non-compressed.");
1074         }
1075         if (!(args->vol_flags & FILE_PERSISTENT_ACLS)) {
1076                 if (args->extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS) {
1077                         ERROR("Strict ACLs requested, but the volume does not "
1078                               "support ACLs!");
1079                         return WIMLIB_ERR_VOLUME_LACKS_FEATURES;
1080                 } else {
1081                         WARNING("Volume does not support persistent ACLS!\n"
1082                                 "          File permissions will not be extracted.");
1083                 }
1084         }
1085         return 0;
1086 }
1087
1088 /*
1089  * Try extracting a hard link.
1090  *
1091  * @output_path:  Path to link to be extracted.
1092  *
1093  * @inode:        WIM inode that the link is to; inode->i_extracted_file
1094  *                the path to a name of the file that has already been
1095  *                extracted (we use this to create the hard link).
1096  *
1097  * @args:         Additional apply context, used here to keep track of
1098  *                the number of times creating a hard link failed due to
1099  *                ERROR_INVALID_FUNCTION.  This error should indicate that hard
1100  *                links are not supported by the volume, and we would like to
1101  *                warn the user a few times, but not too many times.
1102  *
1103  * Returns 0 if the hard link was successfully extracted.  Returns
1104  * WIMLIB_ERR_LINK (> 0) if an error occurred, other than hard links possibly
1105  * being unsupported by the volume.  Returns a negative value if creating the
1106  * hard link failed due to ERROR_INVALID_FUNCTION.
1107  */
1108 static int
1109 win32_try_hard_link(const wchar_t *output_path, const struct wim_inode *inode,
1110                     struct apply_args *args)
1111 {
1112         DWORD err;
1113
1114         /* There is a volume flag for this (FILE_SUPPORTS_HARD_LINKS),
1115          * but it's only available on Windows 7 and later.  So no use
1116          * even checking it, really.  Instead, CreateHardLinkW() will
1117          * apparently return ERROR_INVALID_FUNCTION if the volume does
1118          * not support hard links. */
1119         DEBUG("Creating hard link \"%ls => %ls\"",
1120               output_path, inode->i_extracted_file);
1121         if (CreateHardLinkW(output_path, inode->i_extracted_file, NULL))
1122                 return 0;
1123
1124         err = GetLastError();
1125         if (err != ERROR_INVALID_FUNCTION) {
1126                 ERROR("Can't create hard link \"%ls => %ls\"",
1127                       output_path, inode->i_extracted_file);
1128                 win32_error(err);
1129                 return WIMLIB_ERR_LINK;
1130         } else {
1131                 args->num_hard_links_failed++;
1132                 if (args->num_hard_links_failed <= MAX_CREATE_HARD_LINK_WARNINGS) {
1133                         WARNING("Can't create hard link \"%ls => %ls\":\n"
1134                                 "          Volume does not support hard links!\n"
1135                                 "          Falling back to extracting a copy of the file.",
1136                                 output_path, inode->i_extracted_file);
1137                 }
1138                 if (args->num_hard_links_failed == MAX_CREATE_HARD_LINK_WARNINGS) {
1139                         WARNING("Suppressing further hard linking warnings...");
1140                 }
1141                 return -1;
1142         }
1143 }
1144
1145 /* Extract a file, directory, reparse point, or hard link to an
1146  * already-extracted file using the Win32 API */
1147 int
1148 win32_do_apply_dentry(const wchar_t *output_path,
1149                       size_t output_path_num_chars,
1150                       struct wim_dentry *dentry,
1151                       struct apply_args *args)
1152 {
1153         int ret;
1154         struct wim_inode *inode = dentry->d_inode;
1155
1156         ret = win32_check_vol_flags(output_path, args);
1157         if (ret)
1158                 return ret;
1159         if (inode->i_nlink > 1 && inode->i_extracted_file != NULL) {
1160                 /* Linked file, with another name already extracted.  Create a
1161                  * hard link. */
1162                 ret = win32_try_hard_link(output_path, inode, args);
1163                 if (ret >= 0)
1164                         return ret;
1165                 /* Negative return value from win32_try_hard_link() indicates
1166                  * that hard links are probably not supported by the volume.
1167                  * Fall back to extracting a copy of the file. */
1168         }
1169
1170         /* If this is a reparse point and the volume does not support reparse
1171          * points, just skip it completely. */
1172         if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
1173             !(args->vol_flags & FILE_SUPPORTS_REPARSE_POINTS))
1174         {
1175                 WARNING("Skipping extraction of reparse point \"%ls\":\n"
1176                         "          Not supported by destination filesystem",
1177                         output_path);
1178         } else {
1179                 /* Create the file, directory, or reparse point, and extract the
1180                  * data streams. */
1181                 ret = win32_extract_streams(dentry, output_path, args);
1182                 if (ret)
1183                         return ret;
1184         }
1185         if (inode->i_extracted_file == NULL) {
1186                 const struct wim_lookup_table_entry *lte;
1187
1188                 /* Tally bytes extracted, including all alternate data streams,
1189                  * unless we extracted a hard link (or, at least extracted a
1190                  * name that was supposed to be a hard link) */
1191                 for (unsigned i = 0; i <= inode->i_num_ads; i++) {
1192                         lte = inode_stream_lte_resolved(inode, i);
1193                         if (lte)
1194                                 args->progress.extract.completed_bytes +=
1195                                                         wim_resource_size(lte);
1196                 }
1197                 if (inode->i_nlink > 1) {
1198                         /* Save extracted path for a later call to
1199                          * CreateHardLinkW() if this inode has multiple links.
1200                          * */
1201                         inode->i_extracted_file = WSTRDUP(output_path);
1202                         if (!inode->i_extracted_file)
1203                                 return WIMLIB_ERR_NOMEM;
1204                 }
1205         }
1206         return 0;
1207 }
1208
1209 /* Set timestamps on an extracted file using the Win32 API */
1210 int
1211 win32_do_apply_dentry_timestamps(const wchar_t *path,
1212                                  size_t path_num_chars,
1213                                  struct wim_dentry *dentry,
1214                                  struct apply_args *args)
1215 {
1216         DWORD err;
1217         HANDLE h;
1218         const struct wim_inode *inode = dentry->d_inode;
1219
1220         if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
1221             !(args->vol_flags & FILE_SUPPORTS_REPARSE_POINTS))
1222         {
1223                 /* Skip reparse points not extracted */
1224                 return 0;
1225         }
1226
1227         /* Windows doesn't let you change the timestamps of the root directory
1228          * (at least on FAT, which is dumb but expected since FAT doesn't store
1229          * any metadata about the root directory...) */
1230         if (path_is_root_of_drive(path))
1231                 return 0;
1232
1233         DEBUG("Opening \"%ls\" to set timestamps", path);
1234         h = win32_open_existing_file(path, FILE_WRITE_ATTRIBUTES);
1235         if (h == INVALID_HANDLE_VALUE) {
1236                 err = GetLastError();
1237                 goto fail;
1238         }
1239
1240         FILETIME creationTime = {.dwLowDateTime = inode->i_creation_time & 0xffffffff,
1241                                  .dwHighDateTime = inode->i_creation_time >> 32};
1242         FILETIME lastAccessTime = {.dwLowDateTime = inode->i_last_access_time & 0xffffffff,
1243                                   .dwHighDateTime = inode->i_last_access_time >> 32};
1244         FILETIME lastWriteTime = {.dwLowDateTime = inode->i_last_write_time & 0xffffffff,
1245                                   .dwHighDateTime = inode->i_last_write_time >> 32};
1246
1247         DEBUG("Calling SetFileTime() on \"%ls\"", path);
1248         if (!SetFileTime(h, &creationTime, &lastAccessTime, &lastWriteTime)) {
1249                 err = GetLastError();
1250                 CloseHandle(h);
1251                 goto fail;
1252         }
1253         DEBUG("Closing \"%ls\"", path);
1254         if (!CloseHandle(h)) {
1255                 err = GetLastError();
1256                 goto fail;
1257         }
1258         goto out;
1259 fail:
1260         /* Only warn if setting timestamps failed; still return 0. */
1261         WARNING("Can't set timestamps on \"%ls\"", path);
1262         win32_error(err);
1263 out:
1264         return 0;
1265 }
1266
1267 #endif /* __WIN32__ */