wimlib.net Git - wimlib/blob - src/win32.c

   1 /*
   2  * win32.c
   3  *
   4  * All the library code specific to native Windows builds is in here.
   5  */
   6
   7 /*
   8  * Copyright (C) 2013 Eric Biggers
   9  *
  10  * This file is part of wimlib, a library for working with WIM files.
  11  *
  12  * wimlib is free software; you can redistribute it and/or modify it under the
  13  * terms of the GNU General Public License as published by the Free
  14  * Software Foundation; either version 3 of the License, or (at your option)
  15  * any later version.
  16  *
  17  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
  18  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  19  * A PARTICULAR PURPOSE. See the GNU General Public License for more
  20  * details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  24  */
  25
  26 #ifdef __WIN32__
  27
  28 #include "config.h"
  29 #include <windows.h>
  30 #include <ntdef.h>
  31 #include <wchar.h>
  32 #include <shlwapi.h> /* shlwapi.h for PathMatchSpecW() */
  33 #ifdef ERROR /* windows.h defines this */
  34 #  undef ERROR
  35 #endif
  36
  37 #include "win32.h"
  38 #include "dentry.h"
  39 #include "lookup_table.h"
  40 #include "security.h"
  41 #include "endianness.h"
  42 #include <pthread.h>
  43
  44 #include <errno.h>
  45
  46 #define MAX_GET_SD_ACCESS_DENIED_WARNINGS 1
  47 #define MAX_GET_SACL_PRIV_NOTHELD_WARNINGS 1
  48 struct win32_capture_state {
  49         unsigned long num_get_sd_access_denied;
  50         unsigned long num_get_sacl_priv_notheld;
  51 };
  52
  53 #define MAX_SET_SD_ACCESS_DENIED_WARNINGS 1
  54 #define MAX_SET_SACL_PRIV_NOTHELD_WARNINGS 1
  55
  56 /* Pointers to functions that are not available on all targetted versions of
  57  * Windows (XP and later).  NOTE: The WINAPI annotations seem to be important; I
  58  * assume it specifies a certain calling convention. */
  59
  60 /* Vista and later */
  61 static HANDLE (WINAPI *win32func_FindFirstStreamW)(LPCWSTR lpFileName,
  62                                             STREAM_INFO_LEVELS InfoLevel,
  63                                             LPVOID lpFindStreamData,
  64                                             DWORD dwFlags) = NULL;
  65
  66 /* Vista and later */
  67 static BOOL (WINAPI *win32func_FindNextStreamW)(HANDLE hFindStream,
  68                                          LPVOID lpFindStreamData) = NULL;
  69
  70 static HMODULE hKernel32 = NULL;
  71
  72 /* Try to dynamically load some functions */
  73 void
  74 win32_global_init()
  75 {
  76         DWORD err;
  77
  78         if (hKernel32 == NULL) {
  79                 DEBUG("Loading Kernel32.dll");
  80                 hKernel32 = LoadLibraryW(L"Kernel32.dll");
  81                 if (hKernel32 == NULL) {
  82                         err = GetLastError();
  83                         WARNING("Can't load Kernel32.dll");
  84                         win32_error(err);
  85                         return;
  86                 }
  87         }
  88
  89         DEBUG("Looking for FindFirstStreamW");
  90         win32func_FindFirstStreamW = (void*)GetProcAddress(hKernel32, "FindFirstStreamW");
  91         if (!win32func_FindFirstStreamW) {
  92                 WARNING("Could not find function FindFirstStreamW() in Kernel32.dll!");
  93                 WARNING("Capturing alternate data streams will not be supported.");
  94                 return;
  95         }
  96
  97         DEBUG("Looking for FindNextStreamW");
  98         win32func_FindNextStreamW = (void*)GetProcAddress(hKernel32, "FindNextStreamW");
  99         if (!win32func_FindNextStreamW) {
 100                 WARNING("Could not find function FindNextStreamW() in Kernel32.dll!");
 101                 WARNING("Capturing alternate data streams will not be supported.");
 102                 win32func_FindFirstStreamW = NULL;
 103         }
 104 }
 105
 106 void
 107 win32_global_cleanup()
 108 {
 109         if (hKernel32 != NULL) {
 110                 DEBUG("Closing Kernel32.dll");
 111                 FreeLibrary(hKernel32);
 112                 hKernel32 = NULL;
 113         }
 114 }
 115
 116 static const wchar_t *capture_access_denied_msg =
 117 L"         If you are not running this program as the administrator, you may\n"
 118  "         need to do so, so that all data and metadata can be backed up.\n"
 119  "         Otherwise, there may be no way to access the desired data or\n"
 120  "         metadata without taking ownership of the file or directory.\n"
 121  ;
 122
 123 static const wchar_t *apply_access_denied_msg =
 124 L"If you are not running this program as the administrator, you may\n"
 125  "          need to do so, so that all data and metadata can be extracted\n"
 126  "          exactly as the origignal copy.  However, if you do not care that\n"
 127  "          the security descriptors are extracted correctly, you could run\n"
 128  "          `wimlib-imagex apply' with the --no-acls flag instead.\n"
 129  ;
 130
 131 #ifdef ENABLE_ERROR_MESSAGES
 132 void
 133 win32_error(u32 err_code)
 134 {
 135         wchar_t *buffer;
 136         DWORD nchars;
 137         nchars = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
 138                                     FORMAT_MESSAGE_ALLOCATE_BUFFER,
 139                                 NULL, err_code, 0,
 140                                 (wchar_t*)&buffer, 0, NULL);
 141         if (nchars == 0) {
 142                 ERROR("Error printing error message! "
 143                       "Computer will self-destruct in 3 seconds.");
 144         } else {
 145                 ERROR("Win32 error: %ls", buffer);
 146                 LocalFree(buffer);
 147         }
 148 }
 149
 150 void
 151 win32_error_last()
 152 {
 153         win32_error(GetLastError());
 154 }
 155 #endif
 156
 157 static HANDLE
 158 win32_open_existing_file(const wchar_t *path, DWORD dwDesiredAccess)
 159 {
 160         return CreateFileW(path,
 161                            dwDesiredAccess,
 162                            FILE_SHARE_READ,
 163                            NULL, /* lpSecurityAttributes */
 164                            OPEN_EXISTING,
 165                            FILE_FLAG_BACKUP_SEMANTICS |
 166                                FILE_FLAG_OPEN_REPARSE_POINT,
 167                            NULL /* hTemplateFile */);
 168 }
 169
 170 HANDLE
 171 win32_open_file_data_only(const wchar_t *path)
 172 {
 173         return win32_open_existing_file(path, FILE_READ_DATA);
 174 }
 175
 176 int
 177 win32_read_file(const wchar_t *filename,
 178                 void *handle, u64 offset, size_t size, void *buf)
 179 {
 180         HANDLE h = handle;
 181         DWORD err;
 182         DWORD bytesRead;
 183         LARGE_INTEGER liOffset = {.QuadPart = offset};
 184
 185         wimlib_assert(size <= 0xffffffff);
 186
 187         if (SetFilePointerEx(h, liOffset, NULL, FILE_BEGIN))
 188                 if (ReadFile(h, buf, size, &bytesRead, NULL) && bytesRead == size)
 189                         return 0;
 190         err = GetLastError();
 191         ERROR("Error reading \"%ls\"", filename);
 192         win32_error(err);
 193         return WIMLIB_ERR_READ;
 194 }
 195
 196 void
 197 win32_close_file(void *handle)
 198 {
 199         CloseHandle((HANDLE)handle);
 200 }
 201
 202 static u64
 203 FILETIME_to_u64(const FILETIME *ft)
 204 {
 205         return ((u64)ft->dwHighDateTime << 32) | (u64)ft->dwLowDateTime;
 206 }
 207
 208 static int
 209 win32_get_short_name(struct wim_dentry *dentry, const wchar_t *path)
 210 {
 211         WIN32_FIND_DATAW dat;
 212         if (FindFirstFileW(path, &dat) && dat.cAlternateFileName[0] != L'\0') {
 213                 size_t short_name_nbytes = wcslen(dat.cAlternateFileName) *
 214                                            sizeof(wchar_t);
 215                 size_t n = short_name_nbytes + sizeof(wchar_t);
 216                 dentry->short_name = MALLOC(n);
 217                 if (!dentry->short_name)
 218                         return WIMLIB_ERR_NOMEM;
 219                 memcpy(dentry->short_name, dat.cAlternateFileName, n);
 220                 dentry->short_name_nbytes = short_name_nbytes;
 221         }
 222         /* If we can't read the short filename for some reason, we just ignore
 223          * the error and assume the file has no short name.  I don't think this
 224          * should be an issue, since the short names are essentially obsolete
 225          * anyway. */
 226         return 0;
 227 }
 228
 229 static int
 230 win32_get_security_descriptor(struct wim_dentry *dentry,
 231                               struct sd_set *sd_set,
 232                               const wchar_t *path,
 233                               struct win32_capture_state *state,
 234                               int add_image_flags)
 235 {
 236         SECURITY_INFORMATION requestedInformation;
 237         DWORD lenNeeded = 0;
 238         BOOL status;
 239         DWORD err;
 240         unsigned long n;
 241
 242         requestedInformation = DACL_SECURITY_INFORMATION |
 243                                SACL_SECURITY_INFORMATION |
 244                                OWNER_SECURITY_INFORMATION |
 245                                GROUP_SECURITY_INFORMATION;
 246 again:
 247         /* Request length of security descriptor */
 248         status = GetFileSecurityW(path, requestedInformation,
 249                                   NULL, 0, &lenNeeded);
 250         err = GetLastError();
 251         if (!status && err == ERROR_INSUFFICIENT_BUFFER) {
 252                 DWORD len = lenNeeded;
 253                 char buf[len];
 254                 if (GetFileSecurityW(path, requestedInformation,
 255                                      (PSECURITY_DESCRIPTOR)buf, len, &lenNeeded))
 256                 {
 257                         int security_id = sd_set_add_sd(sd_set, buf, len);
 258                         if (security_id < 0)
 259                                 return WIMLIB_ERR_NOMEM;
 260                         else {
 261                                 dentry->d_inode->i_security_id = security_id;
 262                                 return 0;
 263                         }
 264                 } else {
 265                         err = GetLastError();
 266                 }
 267         }
 268
 269         if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_STRICT_ACLS)
 270                 goto fail;
 271
 272         switch (err) {
 273         case ERROR_PRIVILEGE_NOT_HELD:
 274                 if (requestedInformation & SACL_SECURITY_INFORMATION) {
 275                         n = state->num_get_sacl_priv_notheld++;
 276                         requestedInformation &= ~SACL_SECURITY_INFORMATION;
 277                         if (n < MAX_GET_SACL_PRIV_NOTHELD_WARNINGS) {
 278                                 WARNING(
 279 "We don't have enough privileges to read the full security\n"
 280 "          descriptor of \"%ls\"!\n"
 281 "          Re-trying with SACL omitted.\n", path);
 282                         } else if (n == MAX_GET_SACL_PRIV_NOTHELD_WARNINGS) {
 283                                 WARNING(
 284 "Suppressing further privileges not held error messages when reading\n"
 285 "          security descriptors.");
 286                         }
 287                         goto again;
 288                 }
 289                 /* Fall through */
 290         case ERROR_ACCESS_DENIED:
 291                 n = state->num_get_sd_access_denied++;
 292                 if (n < MAX_GET_SD_ACCESS_DENIED_WARNINGS) {
 293                         WARNING("Failed to read security descriptor of \"%ls\": "
 294                                 "Access denied!\n%ls", path, capture_access_denied_msg);
 295                 } else if (n == MAX_GET_SD_ACCESS_DENIED_WARNINGS) {
 296                         WARNING("Suppressing further access denied errors messages i"
 297                                 "when reading security descriptors");
 298                 }
 299                 return 0;
 300         default:
 301 fail:
 302                 ERROR("Failed to read security descriptor of \"%ls\"", path);
 303                 win32_error(err);
 304                 return WIMLIB_ERR_READ;
 305         }
 306 }
 307
 308 static int
 309 win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
 310                                   wchar_t *path,
 311                                   size_t path_num_chars,
 312                                   struct wim_lookup_table *lookup_table,
 313                                   struct sd_set *sd_set,
 314                                   const struct wimlib_capture_config *config,
 315                                   int add_image_flags,
 316                                   wimlib_progress_func_t progress_func,
 317                                   struct win32_capture_state *state);
 318
 319 /* Reads the directory entries of directory using a Win32 API and recursively
 320  * calls win32_build_dentry_tree() on them. */
 321 static int
 322 win32_recurse_directory(struct wim_dentry *root,
 323                         wchar_t *dir_path,
 324                         size_t dir_path_num_chars,
 325                         struct wim_lookup_table *lookup_table,
 326                         struct sd_set *sd_set,
 327                         const struct wimlib_capture_config *config,
 328                         int add_image_flags,
 329                         wimlib_progress_func_t progress_func,
 330                         struct win32_capture_state *state)
 331 {
 332         WIN32_FIND_DATAW dat;
 333         HANDLE hFind;
 334         DWORD err;
 335         int ret;
 336
 337         /* Begin reading the directory by calling FindFirstFileW.  Unlike UNIX
 338          * opendir(), FindFirstFileW has file globbing built into it.  But this
 339          * isn't what we actually want, so just add a dummy glob to get all
 340          * entries. */
 341         dir_path[dir_path_num_chars] = L'/';
 342         dir_path[dir_path_num_chars + 1] = L'*';
 343         dir_path[dir_path_num_chars + 2] = L'\0';
 344         hFind = FindFirstFileW(dir_path, &dat);
 345         dir_path[dir_path_num_chars] = L'\0';
 346
 347         if (hFind == INVALID_HANDLE_VALUE) {
 348                 err = GetLastError();
 349                 if (err == ERROR_FILE_NOT_FOUND) {
 350                         return 0;
 351                 } else {
 352                         ERROR("Failed to read directory \"%ls\"", dir_path);
 353                         win32_error(err);
 354                         return WIMLIB_ERR_READ;
 355                 }
 356         }
 357         ret = 0;
 358         do {
 359                 /* Skip . and .. entries */
 360                 if (dat.cFileName[0] == L'.' &&
 361                     (dat.cFileName[1] == L'\0' ||
 362                      (dat.cFileName[1] == L'.' &&
 363                       dat.cFileName[2] == L'\0')))
 364                         continue;
 365                 size_t filename_len = wcslen(dat.cFileName);
 366
 367                 dir_path[dir_path_num_chars] = L'/';
 368                 wmemcpy(dir_path + dir_path_num_chars + 1,
 369                         dat.cFileName,
 370                         filename_len + 1);
 371
 372                 struct wim_dentry *child;
 373                 size_t path_len = dir_path_num_chars + 1 + filename_len;
 374                 ret = win32_build_dentry_tree_recursive(&child,
 375                                                         dir_path,
 376                                                         path_len,
 377                                                         lookup_table,
 378                                                         sd_set,
 379                                                         config,
 380                                                         add_image_flags,
 381                                                         progress_func,
 382                                                         state);
 383                 dir_path[dir_path_num_chars] = L'\0';
 384                 if (ret)
 385                         goto out_find_close;
 386                 if (child)
 387                         dentry_add_child(root, child);
 388         } while (FindNextFileW(hFind, &dat));
 389         err = GetLastError();
 390         if (err != ERROR_NO_MORE_FILES) {
 391                 ERROR("Failed to read directory \"%ls\"", dir_path);
 392                 win32_error(err);
 393                 if (ret == 0)
 394                         ret = WIMLIB_ERR_READ;
 395         }
 396 out_find_close:
 397         FindClose(hFind);
 398         return ret;
 399 }
 400
 401 /* Load a reparse point into a WIM inode.  It is just stored in memory.
 402  *
 403  * @hFile:  Open handle to a reparse point, with permission to read the reparse
 404  *          data.
 405  *
 406  * @inode:  WIM inode for the reparse point.
 407  *
 408  * @lookup_table:  Stream lookup table for the WIM; an entry will be added to it
 409  *                 for the reparse point unless an entry already exists for
 410  *                 the exact same data stream.
 411  *
 412  * @path:  External path to the reparse point.  Used for error messages only.
 413  *
 414  * Returns 0 on success; nonzero on failure. */
 415 static int
 416 win32_capture_reparse_point(HANDLE hFile,
 417                             struct wim_inode *inode,
 418                             struct wim_lookup_table *lookup_table,
 419                             const wchar_t *path)
 420 {
 421         /* "Reparse point data, including the tag and optional GUID,
 422          * cannot exceed 16 kilobytes." - MSDN  */
 423         char reparse_point_buf[16 * 1024];
 424         DWORD bytesReturned;
 425
 426         if (!DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT,
 427                              NULL, /* "Not used with this operation; set to NULL" */
 428                              0, /* "Not used with this operation; set to 0" */
 429                              reparse_point_buf, /* "A pointer to a buffer that
 430                                                    receives the reparse point data */
 431                              sizeof(reparse_point_buf), /* "The size of the output
 432                                                            buffer, in bytes */
 433                              &bytesReturned,
 434                              NULL))
 435         {
 436                 DWORD err = GetLastError();
 437                 ERROR("Failed to get reparse data of \"%ls\"", path);
 438                 win32_error(err);
 439                 return WIMLIB_ERR_READ;
 440         }
 441         if (bytesReturned < 8) {
 442                 ERROR("Reparse data on \"%ls\" is invalid", path);
 443                 return WIMLIB_ERR_READ;
 444         }
 445         inode->i_reparse_tag = le32_to_cpu(*(u32*)reparse_point_buf);
 446         return inode_add_ads_with_data(inode, L"",
 447                                        reparse_point_buf + 8,
 448                                        bytesReturned - 8, lookup_table);
 449 }
 450
 451 /* Calculate the SHA1 message digest of a Win32 data stream, which may be either
 452  * an unnamed or named data stream.
 453  *
 454  * @path:       Path to the file, with the stream noted at the end for named
 455  *              streams.  UTF-16LE encoding.
 456  *
 457  * @hash:       On success, the SHA1 message digest of the stream is written to
 458  *              this location.
 459  *
 460  * Returns 0 on success; nonzero on failure.
 461  */
 462 static int
 463 win32_sha1sum(const wchar_t *path, u8 hash[SHA1_HASH_SIZE])
 464 {
 465         HANDLE hFile;
 466         SHA_CTX ctx;
 467         u8 buf[32768];
 468         DWORD bytesRead;
 469         int ret;
 470
 471         hFile = win32_open_file_data_only(path);
 472         if (hFile == INVALID_HANDLE_VALUE)
 473                 return WIMLIB_ERR_OPEN;
 474
 475         sha1_init(&ctx);
 476         for (;;) {
 477                 if (!ReadFile(hFile, buf, sizeof(buf), &bytesRead, NULL)) {
 478                         ret = WIMLIB_ERR_READ;
 479                         goto out_close_handle;
 480                 }
 481                 if (bytesRead == 0)
 482                         break;
 483                 sha1_update(&ctx, buf, bytesRead);
 484         }
 485         ret = 0;
 486         sha1_final(hash, &ctx);
 487 out_close_handle:
 488         CloseHandle(hFile);
 489         return ret;
 490 }
 491
 492 /* Scans an unnamed or named stream of a Win32 file (not a reparse point
 493  * stream); calculates its SHA1 message digest and either creates a `struct
 494  * wim_lookup_table_entry' in memory for it, or uses an existing 'struct
 495  * wim_lookup_table_entry' for an identical stream.
 496  *
 497  * @path:               Path to the file (UTF-16LE).
 498  *
 499  * @path_num_chars:     Number of 2-byte characters in @path.
 500  *
 501  * @inode:              WIM inode to save the stream into.
 502  *
 503  * @lookup_table:       Stream lookup table for the WIM.
 504  *
 505  * @dat:                A `WIN32_FIND_STREAM_DATA' structure that specifies the
 506  *                      stream name.
 507  *
 508  * Returns 0 on success; nonzero on failure.
 509  */
 510 static int
 511 win32_capture_stream(const wchar_t *path,
 512                      size_t path_num_chars,
 513                      struct wim_inode *inode,
 514                      struct wim_lookup_table *lookup_table,
 515                      WIN32_FIND_STREAM_DATA *dat)
 516 {
 517         struct wim_ads_entry *ads_entry;
 518         u8 hash[SHA1_HASH_SIZE];
 519         struct wim_lookup_table_entry *lte;
 520         int ret;
 521         wchar_t *stream_name, *colon;
 522         size_t stream_name_nchars;
 523         bool is_named_stream;
 524         wchar_t *spath;
 525         size_t spath_nchars;
 526         DWORD err;
 527         size_t spath_buf_nbytes;
 528         const wchar_t *relpath_prefix;
 529         const wchar_t *colonchar;
 530
 531         /* The stream name should be returned as :NAME:TYPE */
 532         stream_name = dat->cStreamName;
 533         if (*stream_name != L':')
 534                 goto out_invalid_stream_name;
 535         stream_name += 1;
 536         colon = wcschr(stream_name, L':');
 537         if (colon == NULL)
 538                 goto out_invalid_stream_name;
 539
 540         if (wcscmp(colon + 1, L"$DATA")) {
 541                 /* Not a DATA stream */
 542                 ret = 0;
 543                 goto out;
 544         }
 545
 546         *colon = '\0';
 547
 548         stream_name_nchars = colon - stream_name;
 549         is_named_stream = (stream_name_nchars != 0);
 550
 551         if (is_named_stream) {
 552                 /* Allocate an ADS entry for the named stream. */
 553                 ads_entry = inode_add_ads_utf16le(inode, stream_name,
 554                                                   stream_name_nchars * sizeof(wchar_t));
 555                 if (!ads_entry) {
 556                         ret = WIMLIB_ERR_NOMEM;
 557                         goto out;
 558                 }
 559         }
 560
 561         /* Create a UTF-16LE string @spath that gives the filename, then a
 562          * colon, then the stream name.  Or, if it's an unnamed stream, just the
 563          * filename.  It is MALLOC()'ed so that it can be saved in the
 564          * wim_lookup_table_entry if needed.
 565          *
 566          * As yet another special case, relative paths need to be changed to
 567          * begin with an explicit "./" so that, for example, a file t:ads, where
 568          * :ads is the part we added, is not interpreted as a file on the t:
 569          * drive. */
 570         spath_nchars = path_num_chars;
 571         relpath_prefix = L"";
 572         colonchar = L"";
 573         if (is_named_stream) {
 574                 spath_nchars += 1 + stream_name_nchars;
 575                 colonchar = L":";
 576                 if (path_num_chars == 1 &&
 577                     path[0] != L'/' &&
 578                     path[0] != L'\\')
 579                 {
 580                         spath_nchars += 2;
 581                         relpath_prefix = L"./";
 582                 }
 583         }
 584
 585         spath_buf_nbytes = (spath_nchars + 1) * sizeof(wchar_t);
 586         spath = MALLOC(spath_buf_nbytes);
 587
 588         swprintf(spath, L"%ls%ls%ls%ls",
 589                  relpath_prefix, path, colonchar, stream_name);
 590
 591         ret = win32_sha1sum(spath, hash);
 592         if (ret) {
 593                 err = GetLastError();
 594                 ERROR("Failed to read \"%ls\" to calculate SHA1sum", spath);
 595                 win32_error(err);
 596                 goto out_free_spath;
 597         }
 598
 599         lte = __lookup_resource(lookup_table, hash);
 600         if (lte) {
 601                 /* Use existing wim_lookup_table_entry that has the same SHA1
 602                  * message digest */
 603                 lte->refcnt++;
 604         } else {
 605                 /* Make a new wim_lookup_table_entry */
 606                 lte = new_lookup_table_entry();
 607                 if (!lte) {
 608                         ret = WIMLIB_ERR_NOMEM;
 609                         goto out_free_spath;
 610                 }
 611                 lte->file_on_disk = spath;
 612                 lte->win32_file_on_disk_fp = INVALID_HANDLE_VALUE;
 613                 spath = NULL;
 614                 lte->resource_location = RESOURCE_WIN32;
 615                 lte->resource_entry.original_size = (uint64_t)dat->StreamSize.QuadPart;
 616                 lte->resource_entry.size = (uint64_t)dat->StreamSize.QuadPart;
 617                 copy_hash(lte->hash, hash);
 618                 lookup_table_insert(lookup_table, lte);
 619         }
 620         if (is_named_stream)
 621                 ads_entry->lte = lte;
 622         else
 623                 inode->i_lte = lte;
 624 out_free_spath:
 625         FREE(spath);
 626 out:
 627         return ret;
 628 out_invalid_stream_name:
 629         ERROR("Invalid stream name: \"%ls:%ls\"", path, dat->cStreamName);
 630         ret = WIMLIB_ERR_READ;
 631         goto out;
 632 }
 633
 634 /* Scans a Win32 file for unnamed and named data streams (not reparse point
 635  * streams).
 636  *
 637  * @path:               Path to the file (UTF-16LE).
 638  *
 639  * @path_num_chars:     Number of 2-byte characters in @path.
 640  *
 641  * @inode:              WIM inode to save the stream into.
 642  *
 643  * @lookup_table:       Stream lookup table for the WIM.
 644  *
 645  * @file_size:          Size of unnamed data stream.  (Used only if alternate
 646  *                      data streams API appears to be unavailable.)
 647  *
 648  * Returns 0 on success; nonzero on failure.
 649  */
 650 static int
 651 win32_capture_streams(const wchar_t *path,
 652                       size_t path_num_chars,
 653                       struct wim_inode *inode,
 654                       struct wim_lookup_table *lookup_table,
 655                       u64 file_size)
 656 {
 657         WIN32_FIND_STREAM_DATA dat;
 658         int ret;
 659         HANDLE hFind;
 660         DWORD err;
 661
 662         if (win32func_FindFirstStreamW == NULL)
 663                 goto unnamed_only;
 664
 665         hFind = win32func_FindFirstStreamW(path, FindStreamInfoStandard, &dat, 0);
 666         if (hFind == INVALID_HANDLE_VALUE) {
 667                 err = GetLastError();
 668
 669                 if (err == ERROR_CALL_NOT_IMPLEMENTED)
 670                         goto unnamed_only;
 671
 672                 /* Seems legal for this to return ERROR_HANDLE_EOF on reparse
 673                  * points and directories */
 674                 if ((inode->i_attributes &
 675                     (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY))
 676                     && err == ERROR_HANDLE_EOF)
 677                 {
 678                         return 0;
 679                 } else {
 680                         if (err == ERROR_ACCESS_DENIED) {
 681                                 /* XXX This maybe should be an error. */
 682                                 WARNING("Failed to look up data streams "
 683                                         "of \"%ls\": Access denied!\n%ls",
 684                                         path, capture_access_denied_msg);
 685                                 return 0;
 686                         } else {
 687                                 ERROR("Failed to look up data streams "
 688                                       "of \"%ls\"", path);
 689                                 win32_error(err);
 690                                 return WIMLIB_ERR_READ;
 691                         }
 692                 }
 693         }
 694         do {
 695                 ret = win32_capture_stream(path,
 696                                            path_num_chars,
 697                                            inode, lookup_table,
 698                                            &dat);
 699                 if (ret)
 700                         goto out_find_close;
 701         } while (win32func_FindNextStreamW(hFind, &dat));
 702         err = GetLastError();
 703         if (err != ERROR_HANDLE_EOF) {
 704                 ERROR("Win32 API: Error reading data streams from \"%ls\"", path);
 705                 win32_error(err);
 706                 ret = WIMLIB_ERR_READ;
 707         }
 708 out_find_close:
 709         FindClose(hFind);
 710         return ret;
 711 unnamed_only:
 712         /* FindFirstStreamW() API is not available.  Only capture the unnamed
 713          * data stream. */
 714         if (inode->i_attributes &
 715              (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY))
 716         {
 717                 ret = 0;
 718         } else {
 719                 /* Just create our own WIN32_FIND_STREAM_DATA for an unnamed
 720                  * stream to reduce the code to a call to the
 721                  * already-implemented win32_capture_stream() */
 722                 wcscpy(dat.cStreamName, L"::$DATA");
 723                 dat.StreamSize.QuadPart = file_size;
 724                 ret = win32_capture_stream(path,
 725                                            path_num_chars,
 726                                            inode, lookup_table,
 727                                            &dat);
 728         }
 729         return ret;
 730 }
 731
 732 static int
 733 win32_build_dentry_tree_recursive(struct wim_dentry **root_ret,
 734                                   wchar_t *path,
 735                                   size_t path_num_chars,
 736                                   struct wim_lookup_table *lookup_table,
 737                                   struct sd_set *sd_set,
 738                                   const struct wimlib_capture_config *config,
 739                                   int add_image_flags,
 740                                   wimlib_progress_func_t progress_func,
 741                                   struct win32_capture_state *state)
 742 {
 743         struct wim_dentry *root = NULL;
 744         struct wim_inode *inode;
 745         DWORD err;
 746         u64 file_size;
 747         int ret = 0;
 748
 749         if (exclude_path(path, path_num_chars, config, true)) {
 750                 if (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_ROOT) {
 751                         ERROR("Cannot exclude the root directory from capture");
 752                         ret = WIMLIB_ERR_INVALID_CAPTURE_CONFIG;
 753                         goto out;
 754                 }
 755                 if ((add_image_flags & WIMLIB_ADD_IMAGE_FLAG_EXCLUDE_VERBOSE)
 756                     && progress_func)
 757                 {
 758                         union wimlib_progress_info info;
 759                         info.scan.cur_path = path;
 760                         info.scan.excluded = true;
 761                         progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
 762                 }
 763                 goto out;
 764         }
 765
 766         if ((add_image_flags & WIMLIB_ADD_IMAGE_FLAG_VERBOSE)
 767             && progress_func)
 768         {
 769                 union wimlib_progress_info info;
 770                 info.scan.cur_path = path;
 771                 info.scan.excluded = false;
 772                 progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
 773         }
 774
 775         HANDLE hFile = win32_open_existing_file(path,
 776                                                 FILE_READ_DATA | FILE_READ_ATTRIBUTES);
 777         if (hFile == INVALID_HANDLE_VALUE) {
 778                 err = GetLastError();
 779                 ERROR("Win32 API: Failed to open \"%ls\"", path);
 780                 win32_error(err);
 781                 ret = WIMLIB_ERR_OPEN;
 782                 goto out;
 783         }
 784
 785         BY_HANDLE_FILE_INFORMATION file_info;
 786         if (!GetFileInformationByHandle(hFile, &file_info)) {
 787                 err = GetLastError();
 788                 ERROR("Win32 API: Failed to get file information for \"%ls\"",
 789                       path);
 790                 win32_error(err);
 791                 ret = WIMLIB_ERR_STAT;
 792                 goto out_close_handle;
 793         }
 794
 795         /* Create a WIM dentry */
 796         ret = new_dentry_with_timeless_inode(path_basename_with_len(path, path_num_chars),
 797                                              &root);
 798         if (ret)
 799                 goto out_close_handle;
 800
 801         /* Start preparing the associated WIM inode */
 802         inode = root->d_inode;
 803
 804         inode->i_attributes = file_info.dwFileAttributes;
 805         inode->i_creation_time = FILETIME_to_u64(&file_info.ftCreationTime);
 806         inode->i_last_write_time = FILETIME_to_u64(&file_info.ftLastWriteTime);
 807         inode->i_last_access_time = FILETIME_to_u64(&file_info.ftLastAccessTime);
 808         inode->i_ino = ((u64)file_info.nFileIndexHigh << 32) |
 809                         (u64)file_info.nFileIndexLow;
 810
 811         inode->i_resolved = 1;
 812         add_image_flags &= ~(WIMLIB_ADD_IMAGE_FLAG_ROOT | WIMLIB_ADD_IMAGE_FLAG_SOURCE);
 813
 814         /* Get DOS name and security descriptor (if any). */
 815         ret = win32_get_short_name(root, path);
 816         if (ret)
 817                 goto out_close_handle;
 818
 819         if (!(add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS)) {
 820                 ret = win32_get_security_descriptor(root, sd_set, path, state,
 821                                                     add_image_flags);
 822                 if (ret)
 823                         goto out_close_handle;
 824         }
 825
 826         file_size = ((u64)file_info.nFileSizeHigh << 32) |
 827                      (u64)file_info.nFileSizeLow;
 828
 829         if (inode_is_directory(inode)) {
 830                 /* Directory (not a reparse point) --- recurse to children */
 831
 832                 /* But first... directories may have alternate data streams that
 833                  * need to be captured. */
 834                 ret = win32_capture_streams(path,
 835                                             path_num_chars,
 836                                             inode,
 837                                             lookup_table,
 838                                             file_size);
 839                 if (ret)
 840                         goto out_close_handle;
 841                 ret = win32_recurse_directory(root,
 842                                               path,
 843                                               path_num_chars,
 844                                               lookup_table,
 845                                               sd_set,
 846                                               config,
 847                                               add_image_flags,
 848                                               progress_func,
 849                                               state);
 850         } else if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
 851                 /* Reparse point: save the reparse tag and data.  Alternate data
 852                  * streams are not captured, if it's even possible for a reparse
 853                  * point to have alternate data streams... */
 854                 ret = win32_capture_reparse_point(hFile,
 855                                                   inode,
 856                                                   lookup_table,
 857                                                   path);
 858         } else {
 859                 /* Not a directory, not a reparse point; capture the default
 860                  * file contents and any alternate data streams. */
 861                 ret = win32_capture_streams(path,
 862                                             path_num_chars,
 863                                             inode,
 864                                             lookup_table,
 865                                             file_size);
 866         }
 867 out_close_handle:
 868         CloseHandle(hFile);
 869 out:
 870         if (ret == 0)
 871                 *root_ret = root;
 872         else
 873                 free_dentry_tree(root, lookup_table);
 874         return ret;
 875 }
 876
 877 static void
 878 win32_do_capture_warnings(const struct win32_capture_state *state,
 879                           int add_image_flags)
 880 {
 881         if (state->num_get_sacl_priv_notheld == 0 &&
 882             state->num_get_sd_access_denied == 0)
 883                 return;
 884
 885         WARNING("");
 886         WARNING("Built dentry tree successfully, but with the following problem(s):");
 887         if (state->num_get_sacl_priv_notheld != 0) {
 888                 WARNING("Could not capture SACL (System Access Control List)\n"
 889                         "          on %lu files or directories.",
 890                         state->num_get_sacl_priv_notheld);
 891         }
 892         if (state->num_get_sd_access_denied != 0) {
 893                 WARNING("Could not capture security descriptor at all\n"
 894                         "          on %lu files or directories.",
 895                         state->num_get_sd_access_denied);
 896         }
 897         WARNING(
 898           "Try running the program as the Administrator to make sure all the\n"
 899 "          desired metadata has been captured exactly.  However, if you\n"
 900 "          do not care about capturing security descriptors correctly, then\n"
 901 "          nothing more needs to be done%ls\n",
 902         (add_image_flags & WIMLIB_ADD_IMAGE_FLAG_NO_ACLS) ? L"." :
 903          L", although you might consider\n"
 904 "          passing the --no-acls flag to `wimlib-imagex capture' or\n"
 905 "          `wimlib-imagex append' to explicitly capture no security\n"
 906 "          descriptors.\n");
 907 }
 908
 909 /* Win32 version of capturing a directory tree */
 910 int
 911 win32_build_dentry_tree(struct wim_dentry **root_ret,
 912                         const wchar_t *root_disk_path,
 913                         struct wim_lookup_table *lookup_table,
 914                         struct sd_set *sd_set,
 915                         const struct wimlib_capture_config *config,
 916                         int add_image_flags,
 917                         wimlib_progress_func_t progress_func,
 918                         void *extra_arg)
 919 {
 920         size_t path_nchars;
 921         wchar_t *path;
 922         int ret;
 923         struct win32_capture_state state;
 924
 925         path_nchars = wcslen(root_disk_path);
 926         if (path_nchars > 32767)
 927                 return WIMLIB_ERR_INVALID_PARAM;
 928
 929         /* There is no check for overflow later when this buffer is being used!
 930          * But the max path length on NTFS is 32767 characters, and paths need
 931          * to be written specially to even go past 260 characters, so we should
 932          * be okay with 32770 characters. */
 933         path = MALLOC(32770 * sizeof(wchar_t));
 934         if (!path)
 935                 return WIMLIB_ERR_NOMEM;
 936
 937         wmemcpy(path, root_disk_path, path_nchars + 1);
 938
 939         memset(&state, 0, sizeof(state));
 940         ret = win32_build_dentry_tree_recursive(root_ret,
 941                                                 path,
 942                                                 path_nchars,
 943                                                 lookup_table,
 944                                                 sd_set,
 945                                                 config,
 946                                                 add_image_flags,
 947                                                 progress_func,
 948                                                 &state);
 949         FREE(path);
 950         if (ret == 0)
 951                 win32_do_capture_warnings(&state, add_image_flags);
 952         return ret;
 953 }
 954
 955 static int
 956 win32_set_reparse_data(HANDLE h,
 957                        u32 reparse_tag,
 958                        const struct wim_lookup_table_entry *lte,
 959                        const wchar_t *path)
 960 {
 961         int ret;
 962         u8 *buf;
 963         size_t len;
 964
 965         if (!lte) {
 966                 WARNING("\"%ls\" is marked as a reparse point but had no reparse data",
 967                         path);
 968                 return 0;
 969         }
 970         len = wim_resource_size(lte);
 971         if (len > 16 * 1024 - 8) {
 972                 WARNING("\"%ls\": reparse data too long!", path);
 973                 return 0;
 974         }
 975
 976         /* The WIM stream omits the ReparseTag and ReparseDataLength fields, so
 977          * leave 8 bytes of space for them at the beginning of the buffer, then
 978          * set them manually. */
 979         buf = alloca(len + 8);
 980         ret = read_full_wim_resource(lte, buf + 8, 0);
 981         if (ret)
 982                 return ret;
 983         *(u32*)(buf + 0) = cpu_to_le32(reparse_tag);
 984         *(u16*)(buf + 4) = cpu_to_le16(len);
 985         *(u16*)(buf + 6) = 0;
 986
 987         /* Set the reparse data on the open file using the
 988          * FSCTL_SET_REPARSE_POINT ioctl.
 989          *
 990          * There are contradictions in Microsoft's documentation for this:
 991          *
 992          * "If hDevice was opened without specifying FILE_FLAG_OVERLAPPED,
 993          * lpOverlapped is ignored."
 994          *
 995          * --- So setting lpOverlapped to NULL is okay since it's ignored.
 996          *
 997          * "If lpOverlapped is NULL, lpBytesReturned cannot be NULL. Even when an
 998          * operation returns no output data and lpOutBuffer is NULL,
 999          * DeviceIoControl makes use of lpBytesReturned. After such an
1000          * operation, the value of lpBytesReturned is meaningless."
1001          *
1002          * --- So lpOverlapped not really ignored, as it affects another
1003          *  parameter.  This is the actual behavior: lpBytesReturned must be
1004          *  specified, even though lpBytesReturned is documented as:
1005          *
1006          *  "Not used with this operation; set to NULL."
1007          */
1008         DWORD bytesReturned;
1009         if (!DeviceIoControl(h, FSCTL_SET_REPARSE_POINT, buf, len + 8,
1010                              NULL, 0,
1011                              &bytesReturned /* lpBytesReturned */,
1012                              NULL /* lpOverlapped */))
1013         {
1014                 DWORD err = GetLastError();
1015                 ERROR("Failed to set reparse data on \"%ls\"", path);
1016                 win32_error(err);
1017                 return WIMLIB_ERR_WRITE;
1018         }
1019         return 0;
1020 }
1021
1022 /*
1023  * Sets the security descriptor on an extracted file.
1024  */
1025 static int
1026 win32_set_security_data(const struct wim_inode *inode,
1027                         const wchar_t *path,
1028                         struct apply_args *args)
1029 {
1030         PSECURITY_DESCRIPTOR descriptor;
1031         unsigned long n;
1032         DWORD err;
1033
1034         descriptor = wim_const_security_data(args->w)->descriptors[inode->i_security_id];
1035
1036         SECURITY_INFORMATION securityInformation = DACL_SECURITY_INFORMATION |
1037                                                    SACL_SECURITY_INFORMATION |
1038                                                    OWNER_SECURITY_INFORMATION |
1039                                                    GROUP_SECURITY_INFORMATION;
1040 again:
1041         if (SetFileSecurityW(path, securityInformation, descriptor))
1042                 return 0;
1043         err = GetLastError();
1044         if (args->extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
1045                 goto fail;
1046         switch (err) {
1047         case ERROR_PRIVILEGE_NOT_HELD:
1048                 if (securityInformation & SACL_SECURITY_INFORMATION) {
1049                         n = args->num_set_sacl_priv_notheld++;
1050                         securityInformation &= ~SACL_SECURITY_INFORMATION;
1051                         if (n < MAX_SET_SACL_PRIV_NOTHELD_WARNINGS) {
1052                                 WARNING(
1053 "We don't have enough privileges to set the full security\n"
1054 "          descriptor on \"%ls\"!\n", path);
1055                                 if (args->num_set_sd_access_denied +
1056                                     args->num_set_sacl_priv_notheld == 1)
1057                                 {
1058                                         WARNING("%ls", apply_access_denied_msg);
1059                                 }
1060                                 WARNING("Re-trying with SACL omitted.\n", path);
1061                         } else if (n == MAX_GET_SACL_PRIV_NOTHELD_WARNINGS) {
1062                                 WARNING(
1063 "Suppressing further 'privileges not held' error messages when setting\n"
1064 "          security descriptors.");
1065                         }
1066                         goto again;
1067                 }
1068                 /* Fall through */
1069         case ERROR_INVALID_OWNER:
1070         case ERROR_ACCESS_DENIED:
1071                 n = args->num_set_sd_access_denied++;
1072                 if (n < MAX_SET_SD_ACCESS_DENIED_WARNINGS) {
1073                         WARNING("Failed to set security descriptor on \"%ls\": "
1074                                 "Access denied!\n", path);
1075                         if (args->num_set_sd_access_denied +
1076                             args->num_set_sacl_priv_notheld == 1)
1077                         {
1078                                 WARNING("%ls", apply_access_denied_msg);
1079                         }
1080                 } else if (n == MAX_SET_SD_ACCESS_DENIED_WARNINGS) {
1081                         WARNING(
1082 "Suppressing further access denied error messages when setting\n"
1083 "          security descriptors");
1084                 }
1085                 return 0;
1086         default:
1087 fail:
1088                 ERROR("Failed to set security descriptor on \"%ls\"", path);
1089                 win32_error(err);
1090                 return WIMLIB_ERR_WRITE;
1091         }
1092 }
1093
1094
1095 static int
1096 win32_extract_chunk(const void *buf, size_t len, u64 offset, void *arg)
1097 {
1098         HANDLE hStream = arg;
1099
1100         DWORD nbytes_written;
1101         wimlib_assert(len <= 0xffffffff);
1102
1103         if (!WriteFile(hStream, buf, len, &nbytes_written, NULL) ||
1104             nbytes_written != len)
1105         {
1106                 DWORD err = GetLastError();
1107                 ERROR("WriteFile(): write error");
1108                 win32_error(err);
1109                 return WIMLIB_ERR_WRITE;
1110         }
1111         return 0;
1112 }
1113
1114 static int
1115 do_win32_extract_stream(HANDLE hStream, struct wim_lookup_table_entry *lte)
1116 {
1117         return extract_wim_resource(lte, wim_resource_size(lte),
1118                                     win32_extract_chunk, hStream);
1119 }
1120
1121 static bool
1122 path_is_root_of_drive(const wchar_t *path)
1123 {
1124         if (!*path)
1125                 return false;
1126
1127         if (*path != L'/' && *path != L'\\') {
1128                 if (*(path + 1) == L':')
1129                         path += 2;
1130                 else
1131                         return false;
1132         }
1133         while (*path == L'/' || *path == L'\\')
1134                 path++;
1135         return (*path == L'\0');
1136 }
1137
1138 static int
1139 win32_extract_stream(const struct wim_inode *inode,
1140                      const wchar_t *path,
1141                      const wchar_t *stream_name_utf16,
1142                      struct wim_lookup_table_entry *lte)
1143 {
1144         wchar_t *stream_path;
1145         HANDLE h;
1146         int ret;
1147         DWORD err;
1148         DWORD creationDisposition = CREATE_ALWAYS;
1149
1150         if (stream_name_utf16) {
1151                 /* Named stream.  Create a buffer that contains the UTF-16LE
1152                  * string [.\]@path:@stream_name_utf16.  This is needed to
1153                  * create and open the stream using CreateFileW().  I'm not
1154                  * aware of any other APIs to do this.  Note: the '$DATA' suffix
1155                  * seems to be unneeded.  Additional note: a "./" prefix needs
1156                  * to be added when the path is not absolute to avoid ambiguity
1157                  * with drive letters. */
1158                 size_t stream_path_nchars;
1159                 size_t path_nchars;
1160                 size_t stream_name_nchars;
1161                 const wchar_t *prefix;
1162
1163                 path_nchars = wcslen(path);
1164                 stream_name_nchars = wcslen(stream_name_utf16);
1165                 stream_path_nchars = path_nchars + 1 + stream_name_nchars;
1166                 if (path[0] != cpu_to_le16(L'\0') &&
1167                     path[0] != cpu_to_le16(L'/') &&
1168                     path[0] != cpu_to_le16(L'\\') &&
1169                     path[1] != cpu_to_le16(L':'))
1170                 {
1171                         prefix = L"./";
1172                         stream_path_nchars += 2;
1173                 } else {
1174                         prefix = L"";
1175                 }
1176                 stream_path = alloca((stream_path_nchars + 1) * sizeof(wchar_t));
1177                 swprintf(stream_path, L"%ls%ls:%ls",
1178                          prefix, path, stream_name_utf16);
1179         } else {
1180                 /* Unnamed stream; its path is just the path to the file itself.
1181                  * */
1182                 stream_path = (wchar_t*)path;
1183
1184                 /* Directories must be created with CreateDirectoryW().  Then
1185                  * the call to CreateFileW() will merely open the directory that
1186                  * was already created rather than creating a new file. */
1187                 if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
1188                         if (!CreateDirectoryW(stream_path, NULL)) {
1189                                 err = GetLastError();
1190                                 switch (err) {
1191                                 case ERROR_ALREADY_EXISTS:
1192                                         break;
1193                                 case ERROR_ACCESS_DENIED:
1194                                         if (path_is_root_of_drive(path))
1195                                                 break;
1196                                         /* Fall through */
1197                                 default:
1198                                         ERROR("Failed to create directory \"%ls\"",
1199                                               stream_path);
1200                                         win32_error(err);
1201                                         ret = WIMLIB_ERR_MKDIR;
1202                                         goto fail;
1203                                 }
1204                         }
1205                         DEBUG("Created directory \"%ls\"", stream_path);
1206                         if (!(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
1207                                 ret = 0;
1208                                 goto out;
1209                         }
1210                         creationDisposition = OPEN_EXISTING;
1211                 }
1212         }
1213
1214         DEBUG("Opening \"%ls\"", stream_path);
1215         h = CreateFileW(stream_path,
1216                         GENERIC_WRITE,
1217                         0,
1218                         NULL,
1219                         creationDisposition,
1220                         FILE_FLAG_OPEN_REPARSE_POINT |
1221                             FILE_FLAG_BACKUP_SEMANTICS |
1222                             inode->i_attributes,
1223                         NULL);
1224         if (h == INVALID_HANDLE_VALUE) {
1225                 err = GetLastError();
1226                 ERROR("Failed to create \"%ls\"", stream_path);
1227                 win32_error(err);
1228                 ret = WIMLIB_ERR_OPEN;
1229                 goto fail;
1230         }
1231
1232         if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
1233             stream_name_utf16 == NULL)
1234         {
1235                 DEBUG("Setting reparse data on \"%ls\"", path);
1236                 ret = win32_set_reparse_data(h, inode->i_reparse_tag, lte, path);
1237                 if (ret)
1238                         goto fail_close_handle;
1239         } else {
1240                 if (lte) {
1241                         DEBUG("Extracting \"%ls\" (len = %"PRIu64")",
1242                               stream_path, wim_resource_size(lte));
1243                         ret = do_win32_extract_stream(h, lte);
1244                         if (ret)
1245                                 goto fail_close_handle;
1246                 }
1247         }
1248
1249         DEBUG("Closing \"%ls\"", stream_path);
1250         if (!CloseHandle(h)) {
1251                 err = GetLastError();
1252                 ERROR("Failed to close \"%ls\"", stream_path);
1253                 win32_error(err);
1254                 ret = WIMLIB_ERR_WRITE;
1255                 goto fail;
1256         }
1257         ret = 0;
1258         goto out;
1259 fail_close_handle:
1260         CloseHandle(h);
1261 fail:
1262         ERROR("Error extracting %ls", stream_path);
1263 out:
1264         return ret;
1265 }
1266
1267 /*
1268  * Creates a file, directory, or reparse point and extracts all streams to it
1269  * (unnamed data stream and/or reparse point stream, plus any alternate data
1270  * streams).  This in Win32-specific code.
1271  *
1272  * @inode:      WIM inode for this file or directory.
1273  * @path:       UTF-16LE external path to extract the inode to.
1274  *
1275  * Returns 0 on success; nonzero on failure.
1276  */
1277 static int
1278 win32_extract_streams(const struct wim_inode *inode,
1279                       const wchar_t *path, u64 *completed_bytes_p)
1280 {
1281         struct wim_lookup_table_entry *unnamed_lte;
1282         int ret;
1283
1284         unnamed_lte = inode_unnamed_lte_resolved(inode);
1285         ret = win32_extract_stream(inode, path, NULL, unnamed_lte);
1286         if (ret)
1287                 goto out;
1288         if (unnamed_lte)
1289                 *completed_bytes_p += wim_resource_size(unnamed_lte);
1290         for (u16 i = 0; i < inode->i_num_ads; i++) {
1291                 const struct wim_ads_entry *ads_entry = &inode->i_ads_entries[i];
1292                 if (ads_entry->stream_name_nbytes != 0) {
1293                         /* Skip special UNIX data entries (see documentation for
1294                          * WIMLIB_ADD_IMAGE_FLAG_UNIX_DATA) */
1295                         if (ads_entry->stream_name_nbytes == WIMLIB_UNIX_DATA_TAG_UTF16LE_NBYTES
1296                             && !memcmp(ads_entry->stream_name,
1297                                        WIMLIB_UNIX_DATA_TAG_UTF16LE,
1298                                        WIMLIB_UNIX_DATA_TAG_UTF16LE_NBYTES))
1299                                 continue;
1300                         ret = win32_extract_stream(inode,
1301                                                    path,
1302                                                    ads_entry->stream_name,
1303                                                    ads_entry->lte);
1304                         if (ret)
1305                                 break;
1306                         if (ads_entry->lte)
1307                                 *completed_bytes_p += wim_resource_size(ads_entry->lte);
1308                 }
1309         }
1310 out:
1311         return ret;
1312 }
1313
1314 /* Extract a file, directory, reparse point, or hard link to an
1315  * already-extracted file using the Win32 API */
1316 int
1317 win32_do_apply_dentry(const wchar_t *output_path,
1318                       size_t output_path_num_chars,
1319                       struct wim_dentry *dentry,
1320                       struct apply_args *args)
1321 {
1322         int ret;
1323         struct wim_inode *inode = dentry->d_inode;
1324         DWORD err;
1325
1326         if (inode->i_nlink > 1 && inode->i_extracted_file != NULL) {
1327                 /* Linked file, with another name already extracted.  Create a
1328                  * hard link. */
1329                 DEBUG("Creating hard link \"%ls => %ls\"",
1330                       output_path, inode->i_extracted_file);
1331                 if (!CreateHardLinkW(output_path, inode->i_extracted_file, NULL)) {
1332                         err = GetLastError();
1333                         ERROR("Can't create hard link \"%ls => %ls\"",
1334                               output_path, inode->i_extracted_file);
1335                         win32_error(err);
1336                         return WIMLIB_ERR_LINK;
1337                 }
1338         } else {
1339                 /* Create the file, directory, or reparse point, and extract the
1340                  * data streams. */
1341                 ret = win32_extract_streams(inode, output_path,
1342                                             &args->progress.extract.completed_bytes);
1343                 if (ret)
1344                         return ret;
1345
1346                 if (inode->i_security_id >= 0 &&
1347                     !(args->extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS))
1348                 {
1349                         ret = win32_set_security_data(inode, output_path, args);
1350                         if (ret)
1351                                 return ret;
1352                 }
1353                 if (inode->i_nlink > 1) {
1354                         /* Save extracted path for a later call to
1355                          * CreateHardLinkW() if this inode has multiple links.
1356                          * */
1357                         inode->i_extracted_file = WSTRDUP(output_path);
1358                         if (!inode->i_extracted_file)
1359                                 ret = WIMLIB_ERR_NOMEM;
1360                 }
1361         }
1362         return 0;
1363 }
1364
1365 /* Set timestamps on an extracted file using the Win32 API */
1366 int
1367 win32_do_apply_dentry_timestamps(const wchar_t *path,
1368                                  size_t path_num_chars,
1369                                  const struct wim_dentry *dentry,
1370                                  const struct apply_args *args)
1371 {
1372         DWORD err;
1373         HANDLE h;
1374         const struct wim_inode *inode = dentry->d_inode;
1375
1376         DEBUG("Opening \"%ls\" to set timestamps", path);
1377         h = win32_open_existing_file(path, FILE_WRITE_ATTRIBUTES);
1378         if (h == INVALID_HANDLE_VALUE) {
1379                 err = GetLastError();
1380                 goto fail;
1381         }
1382
1383         FILETIME creationTime = {.dwLowDateTime = inode->i_creation_time & 0xffffffff,
1384                                  .dwHighDateTime = inode->i_creation_time >> 32};
1385         FILETIME lastAccessTime = {.dwLowDateTime = inode->i_last_access_time & 0xffffffff,
1386                                   .dwHighDateTime = inode->i_last_access_time >> 32};
1387         FILETIME lastWriteTime = {.dwLowDateTime = inode->i_last_write_time & 0xffffffff,
1388                                   .dwHighDateTime = inode->i_last_write_time >> 32};
1389
1390         DEBUG("Calling SetFileTime() on \"%ls\"", path);
1391         if (!SetFileTime(h, &creationTime, &lastAccessTime, &lastWriteTime)) {
1392                 err = GetLastError();
1393                 CloseHandle(h);
1394                 goto fail;
1395         }
1396         DEBUG("Closing \"%ls\"", path);
1397         if (!CloseHandle(h)) {
1398                 err = GetLastError();
1399                 goto fail;
1400         }
1401         goto out;
1402 fail:
1403         /* Only warn if setting timestamps failed; still return 0. */
1404         WARNING("Can't set timestamps on \"%ls\"", path);
1405         win32_error(err);
1406 out:
1407         return 0;
1408 }
1409
1410 /* Replacement for POSIX fsync() */
1411 int
1412 fsync(int fd)
1413 {
1414         DWORD err;
1415         HANDLE h;
1416
1417         h = (HANDLE)_get_osfhandle(fd);
1418         if (h == INVALID_HANDLE_VALUE) {
1419                 err = GetLastError();
1420                 ERROR("Could not get Windows handle for file descriptor");
1421                 win32_error(err);
1422                 errno = EBADF;
1423                 return -1;
1424         }
1425         if (!FlushFileBuffers(h)) {
1426                 err = GetLastError();
1427                 ERROR("Could not flush file buffers to disk");
1428                 win32_error(err);
1429                 errno = EIO;
1430                 return -1;
1431         }
1432         return 0;
1433 }
1434
1435 /* Use the Win32 API to get the number of processors */
1436 unsigned
1437 win32_get_number_of_processors()
1438 {
1439         SYSTEM_INFO sysinfo;
1440         GetSystemInfo(&sysinfo);
1441         return sysinfo.dwNumberOfProcessors;
1442 }
1443
1444 /* Replacement for POSIX-2008 realpath().  Warning: partial functionality only
1445  * (resolved_path must be NULL).   Also I highly doubt that GetFullPathName
1446  * really does the right thing under all circumstances. */
1447 wchar_t *
1448 realpath(const wchar_t *path, wchar_t *resolved_path)
1449 {
1450         DWORD ret;
1451         wimlib_assert(resolved_path == NULL);
1452         DWORD err;
1453
1454         ret = GetFullPathNameW(path, 0, NULL, NULL);
1455         if (!ret) {
1456                 err = GetLastError();
1457                 goto fail_win32;
1458         }
1459
1460         resolved_path = TMALLOC(ret);
1461         if (!resolved_path)
1462                 goto out;
1463         ret = GetFullPathNameW(path, ret, resolved_path, NULL);
1464         if (!ret) {
1465                 err = GetLastError();
1466                 free(resolved_path);
1467                 resolved_path = NULL;
1468                 goto fail_win32;
1469         }
1470         goto out;
1471 fail_win32:
1472         win32_error(err);
1473         errno = -1;
1474 out:
1475         return resolved_path;
1476 }
1477
1478 /* rename() on Windows fails if the destination file exists.  And we need to
1479  * make it work on wide characters.  Fix it. */
1480 int
1481 win32_rename_replacement(const wchar_t *oldpath, const wchar_t *newpath)
1482 {
1483         if (MoveFileExW(oldpath, newpath, MOVEFILE_REPLACE_EXISTING)) {
1484                 return 0;
1485         } else {
1486                 /* As usual, the possible error values are not documented */
1487                 DWORD err = GetLastError();
1488                 ERROR("MoveFileEx(): Can't rename \"%ls\" to \"%ls\"",
1489                       oldpath, newpath);
1490                 win32_error(err);
1491                 errno = -1;
1492                 return -1;
1493         }
1494 }
1495
1496 /* Replacement for POSIX fnmatch() (partial functionality only) */
1497 int
1498 fnmatch(const wchar_t *pattern, const wchar_t *string, int flags)
1499 {
1500         if (PathMatchSpecW(string, pattern))
1501                 return 0;
1502         else
1503                 return FNM_NOMATCH;
1504 }
1505
1506 /* truncate() replacement */
1507 int
1508 win32_truncate_replacement(const wchar_t *path, off_t size)
1509 {
1510         DWORD err = NO_ERROR;
1511         LARGE_INTEGER liOffset;
1512
1513         HANDLE h = win32_open_existing_file(path, GENERIC_WRITE);
1514         if (h == INVALID_HANDLE_VALUE)
1515                 goto fail;
1516
1517         liOffset.QuadPart = size;
1518         if (!SetFilePointerEx(h, liOffset, NULL, FILE_BEGIN))
1519                 goto fail_close_handle;
1520
1521         if (!SetEndOfFile(h))
1522                 goto fail_close_handle;
1523         CloseHandle(h);
1524         return 0;
1525
1526 fail_close_handle:
1527         err = GetLastError();
1528         CloseHandle(h);
1529 fail:
1530         if (err == NO_ERROR)
1531                 err = GetLastError();
1532         ERROR("Can't truncate \"%ls\" to %"PRIu64" bytes", path, size);
1533         win32_error(err);
1534         errno = -1;
1535         return -1;
1536 }
1537
1538
1539 /* This really could be replaced with _wcserror_s, but this doesn't seem to
1540  * actually be available in MSVCRT.DLL on Windows XP (perhaps it's statically
1541  * linked in by Visual Studio...?). */
1542 extern int
1543 win32_strerror_r_replacement(int errnum, wchar_t *buf, size_t buflen)
1544 {
1545         static pthread_mutex_t strerror_lock = PTHREAD_MUTEX_INITIALIZER;
1546
1547         pthread_mutex_lock(&strerror_lock);
1548         mbstowcs(buf, strerror(errnum), buflen);
1549         buf[buflen - 1] = '\0';
1550         pthread_mutex_unlock(&strerror_lock);
1551         return 0;
1552 }
1553
1554 #endif /* __WIN32__ */