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

   1 /*
   2  * extract.c
   3  *
   4  * Support for extracting WIM images, or files or directories contained in a WIM
   5  * image.
   6  */
   7
   8 /*
   9  * Copyright (C) 2012-2016 Eric Biggers
  10  *
  11  * This file is free software; you can redistribute it and/or modify it under
  12  * the terms of the GNU Lesser General Public License as published by the Free
  13  * Software Foundation; either version 3 of the License, or (at your option) any
  14  * later version.
  15  *
  16  * This file is distributed in the hope that it will be useful, but WITHOUT
  17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  18  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  19  * details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this file; if not, see http://www.gnu.org/licenses/.
  23  */
  24
  25 /*
  26  * This file provides the API functions wimlib_extract_image(),
  27  * wimlib_extract_image_from_pipe(), wimlib_extract_paths(), and
  28  * wimlib_extract_pathlist().  Internally, all end up calling
  29  * do_wimlib_extract_paths() and extract_trees().
  30  *
  31  * Although wimlib supports multiple extraction modes/backends (NTFS-3G, UNIX,
  32  * Win32), this file does not itself have code to extract files or directories
  33  * to any specific target; instead, it handles generic functionality and relies
  34  * on lower-level callback functions declared in `struct apply_operations' to do
  35  * the actual extraction.
  36  */
  37
  38 #ifdef HAVE_CONFIG_H
  39 #  include "config.h"
  40 #endif
  41
  42 #include <errno.h>
  43 #include <fcntl.h>
  44 #include <stdlib.h>
  45 #include <sys/stat.h>
  46 #include <unistd.h>
  47
  48 #include "wimlib/apply.h"
  49 #include "wimlib/assert.h"
  50 #include "wimlib/blob_table.h"
  51 #include "wimlib/dentry.h"
  52 #include "wimlib/encoding.h"
  53 #include "wimlib/endianness.h"
  54 #include "wimlib/error.h"
  55 #include "wimlib/metadata.h"
  56 #include "wimlib/object_id.h"
  57 #include "wimlib/pathlist.h"
  58 #include "wimlib/paths.h"
  59 #include "wimlib/pattern.h"
  60 #include "wimlib/reparse.h"
  61 #include "wimlib/resource.h"
  62 #include "wimlib/security.h"
  63 #include "wimlib/unix_data.h"
  64 #include "wimlib/wim.h"
  65 #include "wimlib/win32.h" /* for realpath() equivalent */
  66 #include "wimlib/xml.h"
  67
  68 #define WIMLIB_EXTRACT_FLAG_FROM_PIPE   0x80000000
  69 #define WIMLIB_EXTRACT_FLAG_IMAGEMODE   0x40000000
  70
  71 /* Keep in sync with wimlib.h  */
  72 #define WIMLIB_EXTRACT_MASK_PUBLIC                              \
  73         (WIMLIB_EXTRACT_FLAG_NTFS                       |       \
  74          WIMLIB_EXTRACT_FLAG_UNIX_DATA                  |       \
  75          WIMLIB_EXTRACT_FLAG_NO_ACLS                    |       \
  76          WIMLIB_EXTRACT_FLAG_STRICT_ACLS                |       \
  77          WIMLIB_EXTRACT_FLAG_RPFIX                      |       \
  78          WIMLIB_EXTRACT_FLAG_NORPFIX                    |       \
  79          WIMLIB_EXTRACT_FLAG_TO_STDOUT                  |       \
  80          WIMLIB_EXTRACT_FLAG_REPLACE_INVALID_FILENAMES  |       \
  81          WIMLIB_EXTRACT_FLAG_ALL_CASE_CONFLICTS         |       \
  82          WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS          |       \
  83          WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES         |       \
  84          WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS            |       \
  85          WIMLIB_EXTRACT_FLAG_GLOB_PATHS                 |       \
  86          WIMLIB_EXTRACT_FLAG_STRICT_GLOB                |       \
  87          WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES              |       \
  88          WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE  |       \
  89          WIMLIB_EXTRACT_FLAG_WIMBOOT                    |       \
  90          WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K           |       \
  91          WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K           |       \
  92          WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K          |       \
  93          WIMLIB_EXTRACT_FLAG_COMPACT_LZX                        \
  94          )
  95
  96 /* Send WIMLIB_PROGRESS_MSG_EXTRACT_FILE_STRUCTURE or
  97  * WIMLIB_PROGRESS_MSG_EXTRACT_METADATA.  */
  98 int
  99 do_file_extract_progress(struct apply_ctx *ctx, enum wimlib_progress_msg msg)
 100 {
 101         ctx->count_until_file_progress = 500;  /* Arbitrary value to limit calls  */
 102         return extract_progress(ctx, msg);
 103 }
 104
 105 static int
 106 start_file_phase(struct apply_ctx *ctx, u64 end_file_count, enum wimlib_progress_msg msg)
 107 {
 108         ctx->progress.extract.current_file_count = 0;
 109         ctx->progress.extract.end_file_count = end_file_count;
 110         return do_file_extract_progress(ctx, msg);
 111 }
 112
 113 int
 114 start_file_structure_phase(struct apply_ctx *ctx, u64 end_file_count)
 115 {
 116         return start_file_phase(ctx, end_file_count, WIMLIB_PROGRESS_MSG_EXTRACT_FILE_STRUCTURE);
 117 }
 118
 119 int
 120 start_file_metadata_phase(struct apply_ctx *ctx, u64 end_file_count)
 121 {
 122         return start_file_phase(ctx, end_file_count, WIMLIB_PROGRESS_MSG_EXTRACT_METADATA);
 123 }
 124
 125 static int
 126 end_file_phase(struct apply_ctx *ctx, enum wimlib_progress_msg msg)
 127 {
 128         ctx->progress.extract.current_file_count = ctx->progress.extract.end_file_count;
 129         return do_file_extract_progress(ctx, msg);
 130 }
 131
 132 int
 133 end_file_structure_phase(struct apply_ctx *ctx)
 134 {
 135         return end_file_phase(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_FILE_STRUCTURE);
 136 }
 137
 138 int
 139 end_file_metadata_phase(struct apply_ctx *ctx)
 140 {
 141         return end_file_phase(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_METADATA);
 142 }
 143
 144 /* Are all bytes in the specified buffer zero? */
 145 static bool
 146 is_all_zeroes(const u8 *p, const size_t size)
 147 {
 148         const u8 * const end = p + size;
 149
 150         for (; (uintptr_t)p % WORDBYTES && p != end; p++)
 151                 if (*p)
 152                         return false;
 153
 154         for (; end - p >= WORDBYTES; p += WORDBYTES)
 155                 if (*(const machine_word_t *)p)
 156                         return false;
 157
 158         for (; p != end; p++)
 159                 if (*p)
 160                         return false;
 161
 162         return true;
 163 }
 164
 165 /*
 166  * Sparse regions should be detected at the granularity of the filesystem block
 167  * size.  For now just assume 4096 bytes, which is the default block size on
 168  * NTFS and most Linux filesystems.
 169  */
 170 #define SPARSE_UNIT 4096
 171
 172 /*
 173  * Detect whether the specified buffer begins with a region of all zero bytes.
 174  * Return %true if a zero region was found or %false if a nonzero region was
 175  * found, and sets *len_ret to the length of the region.  This operates at a
 176  * granularity of SPARSE_UNIT bytes, meaning that to extend a zero region, there
 177  * must be SPARSE_UNIT zero bytes with no interruption, but to extend a nonzero
 178  * region, just one nonzero byte in the next SPARSE_UNIT bytes is sufficient.
 179  *
 180  * Note: besides compression, the WIM format doesn't yet have a way to
 181  * efficiently represent zero regions, so that's why we need to detect them
 182  * ourselves.  Things will still fall apart badly on extremely large sparse
 183  * files, but this is a start...
 184  */
 185 bool
 186 detect_sparse_region(const void *data, size_t size, size_t *len_ret)
 187 {
 188         const void *p = data;
 189         const void * const end = data + size;
 190         size_t len = 0;
 191         bool zeroes = false;
 192
 193         while (p != end) {
 194                 size_t n = min(end - p, SPARSE_UNIT);
 195                 bool z = is_all_zeroes(p, n);
 196
 197                 if (len != 0 && z != zeroes)
 198                         break;
 199                 zeroes = z;
 200                 len += n;
 201                 p += n;
 202         }
 203
 204         *len_ret = len;
 205         return zeroes;
 206 }
 207
 208 #define PWM_FOUND_WIM_HDR (-1)
 209
 210 /* Read the header for a blob in a pipable WIM.  If @pwm_hdr_ret is not NULL,
 211  * also look for a pipable WIM header and return PWM_FOUND_WIM_HDR if found.  */
 212 static int
 213 read_pwm_blob_header(WIMStruct *pwm, u8 hash_ret[SHA1_HASH_SIZE],
 214                      struct wim_reshdr *reshdr_ret,
 215                      struct wim_header_disk *pwm_hdr_ret)
 216 {
 217         int ret;
 218         struct pwm_blob_hdr blob_hdr;
 219         u64 magic;
 220
 221         ret = full_read(&pwm->in_fd, &blob_hdr, sizeof(blob_hdr));
 222         if (unlikely(ret))
 223                 goto read_error;
 224
 225         magic = le64_to_cpu(blob_hdr.magic);
 226
 227         if (magic == PWM_MAGIC && pwm_hdr_ret != NULL) {
 228                 memcpy(pwm_hdr_ret, &blob_hdr, sizeof(blob_hdr));
 229                 ret = full_read(&pwm->in_fd,
 230                                 (u8 *)pwm_hdr_ret + sizeof(blob_hdr),
 231                                 sizeof(*pwm_hdr_ret) - sizeof(blob_hdr));
 232                 if (unlikely(ret))
 233                         goto read_error;
 234                 return PWM_FOUND_WIM_HDR;
 235         }
 236
 237         if (unlikely(magic != PWM_BLOB_MAGIC)) {
 238                 ERROR("Data read on pipe is invalid (expected blob header)");
 239                 return WIMLIB_ERR_INVALID_PIPABLE_WIM;
 240         }
 241
 242         copy_hash(hash_ret, blob_hdr.hash);
 243
 244         reshdr_ret->size_in_wim = 0; /* Not available  */
 245         reshdr_ret->flags = le32_to_cpu(blob_hdr.flags);
 246         reshdr_ret->offset_in_wim = pwm->in_fd.offset;
 247         reshdr_ret->uncompressed_size = le64_to_cpu(blob_hdr.uncompressed_size);
 248
 249         if (unlikely(reshdr_ret->uncompressed_size == 0)) {
 250                 ERROR("Data read on pipe is invalid (resource is of 0 size)");
 251                 return WIMLIB_ERR_INVALID_PIPABLE_WIM;
 252         }
 253
 254         return 0;
 255
 256 read_error:
 257         if (ret == WIMLIB_ERR_UNEXPECTED_END_OF_FILE)
 258                 ERROR("The pipe ended before all needed data was sent!");
 259         else
 260                 ERROR_WITH_ERRNO("Error reading pipable WIM from pipe");
 261         return ret;
 262 }
 263
 264 static int
 265 read_blobs_from_pipe(struct apply_ctx *ctx, const struct read_blob_callbacks *cbs)
 266 {
 267         int ret;
 268         u8 hash[SHA1_HASH_SIZE];
 269         struct wim_reshdr reshdr;
 270         struct wim_header_disk pwm_hdr;
 271         struct wim_resource_descriptor rdesc;
 272         struct blob_descriptor *blob;
 273
 274         copy_guid(ctx->progress.extract.guid, ctx->wim->hdr.guid);
 275         ctx->progress.extract.part_number = ctx->wim->hdr.part_number;
 276         ctx->progress.extract.total_parts = ctx->wim->hdr.total_parts;
 277         ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN);
 278         if (ret)
 279                 return ret;
 280
 281         while (ctx->num_blobs_remaining) {
 282
 283                 ret = read_pwm_blob_header(ctx->wim, hash, &reshdr, &pwm_hdr);
 284
 285                 if (ret == PWM_FOUND_WIM_HDR) {
 286                         u16 part_number = le16_to_cpu(pwm_hdr.part_number);
 287                         u16 total_parts = le16_to_cpu(pwm_hdr.total_parts);
 288
 289                         if (part_number == ctx->progress.extract.part_number &&
 290                             total_parts == ctx->progress.extract.total_parts &&
 291                             guids_equal(pwm_hdr.guid, ctx->progress.extract.guid))
 292                                 continue;
 293
 294                         copy_guid(ctx->progress.extract.guid, pwm_hdr.guid);
 295                         ctx->progress.extract.part_number = part_number;
 296                         ctx->progress.extract.total_parts = total_parts;
 297                         ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN);
 298                         if (ret)
 299                                 return ret;
 300
 301                         continue;
 302                 }
 303
 304                 if (ret)
 305                         return ret;
 306
 307                 if (!(reshdr.flags & WIM_RESHDR_FLAG_METADATA)
 308                     && (blob = lookup_blob(ctx->wim->blob_table, hash))
 309                     && (blob->out_refcnt))
 310                 {
 311                         wim_reshdr_to_desc_and_blob(&reshdr, ctx->wim, &rdesc, blob);
 312                         ret = read_blob_with_sha1(blob, cbs);
 313                         blob_unset_is_located_in_wim_resource(blob);
 314                         if (ret)
 315                                 return ret;
 316                         ctx->num_blobs_remaining--;
 317                 } else {
 318                         wim_reshdr_to_desc(&reshdr, ctx->wim, &rdesc);
 319                         ret = skip_wim_resource(&rdesc);
 320                         if (ret)
 321                                 return ret;
 322                 }
 323         }
 324
 325         return 0;
 326 }
 327
 328 static int
 329 handle_pwm_metadata_resource(WIMStruct *pwm, int image, bool is_needed)
 330 {
 331         struct blob_descriptor *blob;
 332         struct wim_reshdr reshdr;
 333         struct wim_resource_descriptor *rdesc;
 334         int ret;
 335
 336         ret = WIMLIB_ERR_NOMEM;
 337         blob = new_blob_descriptor();
 338         if (!blob)
 339                 goto out;
 340
 341         ret = read_pwm_blob_header(pwm, blob->hash, &reshdr, NULL);
 342         if (ret)
 343                 goto out;
 344
 345         ret = WIMLIB_ERR_INVALID_PIPABLE_WIM;
 346         if (!(reshdr.flags & WIM_RESHDR_FLAG_METADATA)) {
 347                 ERROR("Expected metadata resource, but found non-metadata "
 348                       "resource");
 349                 goto out;
 350         }
 351
 352         ret = WIMLIB_ERR_NOMEM;
 353         rdesc = MALLOC(sizeof(*rdesc));
 354         if (!rdesc)
 355                 goto out;
 356
 357         wim_reshdr_to_desc_and_blob(&reshdr, pwm, rdesc, blob);
 358         pwm->refcnt++;
 359
 360         ret = WIMLIB_ERR_NOMEM;
 361         pwm->image_metadata[image - 1] = new_unloaded_image_metadata(blob);
 362         if (!pwm->image_metadata[image - 1])
 363                 goto out;
 364         blob = NULL;
 365
 366         /* If the metadata resource is for the image being extracted, then parse
 367          * it and save the metadata in memory.  Otherwise, skip over it.  */
 368         if (is_needed)
 369                 ret = select_wim_image(pwm, image);
 370         else
 371                 ret = skip_wim_resource(rdesc);
 372 out:
 373         free_blob_descriptor(blob);
 374         return ret;
 375 }
 376
 377 /* Creates a temporary file opened for writing.  The open file descriptor is
 378  * returned in @fd_ret and its name is returned in @name_ret (dynamically
 379  * allocated).  */
 380 static int
 381 create_temporary_file(struct filedes *fd_ret, tchar **name_ret)
 382 {
 383         tchar *name;
 384         int raw_fd;
 385
 386 #ifdef __WIN32__
 387 retry:
 388         name = _wtempnam(NULL, L"wimlib");
 389         if (!name) {
 390                 ERROR_WITH_ERRNO("Failed to create temporary filename");
 391                 return WIMLIB_ERR_NOMEM;
 392         }
 393         raw_fd = _wopen(name, O_WRONLY | O_CREAT | O_EXCL | O_BINARY |
 394                         _O_SHORT_LIVED, 0600);
 395         if (raw_fd < 0 && errno == EEXIST) {
 396                 FREE(name);
 397                 goto retry;
 398         }
 399 #else /* __WIN32__ */
 400         const char *tmpdir = getenv("TMPDIR");
 401         if (!tmpdir)
 402                 tmpdir = P_tmpdir;
 403         name = MALLOC(strlen(tmpdir) + 1 + 6 + 6 + 1);
 404         if (!name)
 405                 return WIMLIB_ERR_NOMEM;
 406         sprintf(name, "%s/wimlibXXXXXX", tmpdir);
 407         raw_fd = mkstemp(name);
 408 #endif /* !__WIN32__ */
 409
 410         if (raw_fd < 0) {
 411                 ERROR_WITH_ERRNO("Failed to create temporary file "
 412                                  "\"%"TS"\"", name);
 413                 FREE(name);
 414                 return WIMLIB_ERR_OPEN;
 415         }
 416
 417         filedes_init(fd_ret, raw_fd);
 418         *name_ret = name;
 419         return 0;
 420 }
 421
 422 static int
 423 begin_extract_blob(struct blob_descriptor *blob, void *_ctx)
 424 {
 425         struct apply_ctx *ctx = _ctx;
 426
 427         if (unlikely(blob->out_refcnt > MAX_OPEN_FILES))
 428                 return create_temporary_file(&ctx->tmpfile_fd, &ctx->tmpfile_name);
 429
 430         return call_begin_blob(blob, ctx->saved_cbs);
 431 }
 432
 433 static int
 434 extract_chunk(const struct blob_descriptor *blob, u64 offset,
 435               const void *chunk, size_t size, void *_ctx)
 436 {
 437         struct apply_ctx *ctx = _ctx;
 438         union wimlib_progress_info *progress = &ctx->progress;
 439         bool last = (offset + size == blob->size);
 440         int ret;
 441
 442         if (likely(ctx->supported_features.hard_links)) {
 443                 progress->extract.completed_bytes +=
 444                         (u64)size * blob->out_refcnt;
 445                 if (last)
 446                         progress->extract.completed_streams += blob->out_refcnt;
 447         } else {
 448                 const struct blob_extraction_target *targets =
 449                         blob_extraction_targets(blob);
 450                 for (u32 i = 0; i < blob->out_refcnt; i++) {
 451                         const struct wim_inode *inode = targets[i].inode;
 452                         const struct wim_dentry *dentry;
 453
 454                         inode_for_each_extraction_alias(dentry, inode) {
 455                                 progress->extract.completed_bytes += size;
 456                                 if (last)
 457                                         progress->extract.completed_streams++;
 458                         }
 459                 }
 460         }
 461         if (progress->extract.completed_bytes >= ctx->next_progress) {
 462
 463                 ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS);
 464                 if (ret)
 465                         return ret;
 466
 467                 set_next_progress(progress->extract.completed_bytes,
 468                                   progress->extract.total_bytes,
 469                                   &ctx->next_progress);
 470         }
 471
 472         if (unlikely(filedes_valid(&ctx->tmpfile_fd))) {
 473                 /* Just extracting to temporary file for now.  */
 474                 ret = full_write(&ctx->tmpfile_fd, chunk, size);
 475                 if (ret) {
 476                         ERROR_WITH_ERRNO("Error writing data to "
 477                                          "temporary file \"%"TS"\"",
 478                                          ctx->tmpfile_name);
 479                 }
 480                 return ret;
 481         }
 482
 483         return call_continue_blob(blob, offset, chunk, size, ctx->saved_cbs);
 484 }
 485
 486 /* Copy the blob's data from the temporary file to each of its targets.
 487  *
 488  * This is executed only in the very uncommon case that a blob is being
 489  * extracted to more than MAX_OPEN_FILES targets!  */
 490 static int
 491 extract_from_tmpfile(const tchar *tmpfile_name,
 492                      const struct blob_descriptor *orig_blob,
 493                      const struct read_blob_callbacks *cbs)
 494 {
 495         struct blob_descriptor tmpfile_blob;
 496         const struct blob_extraction_target *targets = blob_extraction_targets(orig_blob);
 497         int ret;
 498
 499         memcpy(&tmpfile_blob, orig_blob, sizeof(struct blob_descriptor));
 500         tmpfile_blob.blob_location = BLOB_IN_FILE_ON_DISK;
 501         tmpfile_blob.file_on_disk = (tchar *)tmpfile_name;
 502         tmpfile_blob.out_refcnt = 1;
 503
 504         for (u32 i = 0; i < orig_blob->out_refcnt; i++) {
 505                 tmpfile_blob.inline_blob_extraction_targets[0] = targets[i];
 506                 ret = read_blob_with_cbs(&tmpfile_blob, cbs);
 507                 if (ret)
 508                         return ret;
 509         }
 510         return 0;
 511 }
 512
 513 static int
 514 end_extract_blob(struct blob_descriptor *blob, int status, void *_ctx)
 515 {
 516         struct apply_ctx *ctx = _ctx;
 517
 518         if (unlikely(filedes_valid(&ctx->tmpfile_fd))) {
 519                 filedes_close(&ctx->tmpfile_fd);
 520                 if (!status)
 521                         status = extract_from_tmpfile(ctx->tmpfile_name, blob,
 522                                                       ctx->saved_cbs);
 523                 filedes_invalidate(&ctx->tmpfile_fd);
 524                 tunlink(ctx->tmpfile_name);
 525                 FREE(ctx->tmpfile_name);
 526                 return status;
 527         }
 528
 529         return call_end_blob(blob, status, ctx->saved_cbs);
 530 }
 531
 532 /*
 533  * Read the list of blobs to extract and feed their data into the specified
 534  * callback functions.
 535  *
 536  * This handles checksumming each blob.
 537  *
 538  * This also handles sending WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS.
 539  *
 540  * This also works if the WIM is being read from a pipe.
 541  *
 542  * This also will split up blobs that will need to be extracted to more than
 543  * MAX_OPEN_FILES locations, as measured by the 'out_refcnt' of each blob.
 544  * Therefore, the apply_operations implementation need not worry about running
 545  * out of file descriptors, unless it might open more than one file descriptor
 546  * per 'blob_extraction_target' (e.g. Win32 currently might because the
 547  * destination file system might not support hard links).
 548  */
 549 int
 550 extract_blob_list(struct apply_ctx *ctx, const struct read_blob_callbacks *cbs)
 551 {
 552         struct read_blob_callbacks wrapper_cbs = {
 553                 .begin_blob     = begin_extract_blob,
 554                 .continue_blob  = extract_chunk,
 555                 .end_blob       = end_extract_blob,
 556                 .ctx            = ctx,
 557         };
 558         ctx->saved_cbs = cbs;
 559         if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_FROM_PIPE) {
 560                 return read_blobs_from_pipe(ctx, &wrapper_cbs);
 561         } else {
 562                 return read_blob_list(&ctx->blob_list,
 563                                       offsetof(struct blob_descriptor,
 564                                                extraction_list),
 565                                       &wrapper_cbs, VERIFY_BLOB_HASHES);
 566         }
 567 }
 568
 569 /* Extract a WIM dentry to standard output.
 570  *
 571  * This obviously doesn't make sense in all cases.  We return an error if the
 572  * dentry does not correspond to a regular file.  Otherwise we extract the
 573  * unnamed data stream only.  */
 574 static int
 575 extract_dentry_to_stdout(struct wim_dentry *dentry,
 576                          const struct blob_table *blob_table)
 577 {
 578         struct wim_inode *inode = dentry->d_inode;
 579         struct blob_descriptor *blob;
 580         struct filedes _stdout;
 581
 582         if (inode->i_attributes & (FILE_ATTRIBUTE_REPARSE_POINT |
 583                                    FILE_ATTRIBUTE_DIRECTORY |
 584                                    FILE_ATTRIBUTE_ENCRYPTED))
 585         {
 586                 ERROR("\"%"TS"\" is not a regular file and therefore cannot be "
 587                       "extracted to standard output", dentry_full_path(dentry));
 588                 return WIMLIB_ERR_NOT_A_REGULAR_FILE;
 589         }
 590
 591         blob = inode_get_blob_for_unnamed_data_stream(inode, blob_table);
 592         if (!blob) {
 593                 const u8 *hash = inode_get_hash_of_unnamed_data_stream(inode);
 594                 if (!is_zero_hash(hash))
 595                         return blob_not_found_error(inode, hash);
 596                 return 0;
 597         }
 598
 599         filedes_init(&_stdout, STDOUT_FILENO);
 600         return extract_blob_to_fd(blob, &_stdout);
 601 }
 602
 603 static int
 604 extract_dentries_to_stdout(struct wim_dentry **dentries, size_t num_dentries,
 605                            const struct blob_table *blob_table)
 606 {
 607         for (size_t i = 0; i < num_dentries; i++) {
 608                 int ret = extract_dentry_to_stdout(dentries[i], blob_table);
 609                 if (ret)
 610                         return ret;
 611         }
 612         return 0;
 613 }
 614
 615 /**********************************************************************/
 616
 617 /*
 618  * Removes duplicate dentries from the array.
 619  *
 620  * Returns the new number of dentries, packed at the front of the array.
 621  */
 622 static size_t
 623 remove_duplicate_trees(struct wim_dentry **trees, size_t num_trees)
 624 {
 625         size_t i, j = 0;
 626         for (i = 0; i < num_trees; i++) {
 627                 if (!trees[i]->d_tmp_flag) {
 628                         /* Found distinct dentry.  */
 629                         trees[i]->d_tmp_flag = 1;
 630                         trees[j++] = trees[i];
 631                 }
 632         }
 633         for (i = 0; i < j; i++)
 634                 trees[i]->d_tmp_flag = 0;
 635         return j;
 636 }
 637
 638 /*
 639  * Remove dentries that are descendants of other dentries in the array.
 640  *
 641  * Returns the new number of dentries, packed at the front of the array.
 642  */
 643 static size_t
 644 remove_contained_trees(struct wim_dentry **trees, size_t num_trees)
 645 {
 646         size_t i, j = 0;
 647         for (i = 0; i < num_trees; i++)
 648                 trees[i]->d_tmp_flag = 1;
 649         for (i = 0; i < num_trees; i++) {
 650                 struct wim_dentry *d = trees[i];
 651                 while (!dentry_is_root(d)) {
 652                         d = d->d_parent;
 653                         if (d->d_tmp_flag)
 654                                 goto tree_contained;
 655                 }
 656                 trees[j++] = trees[i];
 657                 continue;
 658
 659         tree_contained:
 660                 trees[i]->d_tmp_flag = 0;
 661         }
 662
 663         for (i = 0; i < j; i++)
 664                 trees[i]->d_tmp_flag = 0;
 665         return j;
 666 }
 667
 668 static int
 669 dentry_append_to_list(struct wim_dentry *dentry, void *_dentry_list)
 670 {
 671         struct list_head *dentry_list = _dentry_list;
 672         list_add_tail(&dentry->d_extraction_list_node, dentry_list);
 673         return 0;
 674 }
 675
 676 static void
 677 dentry_reset_extraction_list_node(struct wim_dentry *dentry)
 678 {
 679         dentry->d_extraction_list_node = (struct list_head){NULL, NULL};
 680 }
 681
 682 static int
 683 dentry_delete_from_list(struct wim_dentry *dentry, void *_ignore)
 684 {
 685         if (will_extract_dentry(dentry)) {
 686                 list_del(&dentry->d_extraction_list_node);
 687                 dentry_reset_extraction_list_node(dentry);
 688         }
 689         return 0;
 690 }
 691
 692 /*
 693  * Build the preliminary list of dentries to be extracted.
 694  *
 695  * The list maintains the invariant that if d1 and d2 are in the list and d1 is
 696  * an ancestor of d2, then d1 appears before d2 in the list.
 697  */
 698 static void
 699 build_dentry_list(struct list_head *dentry_list, struct wim_dentry **trees,
 700                   size_t num_trees, bool add_ancestors)
 701 {
 702         INIT_LIST_HEAD(dentry_list);
 703
 704         /* Add the trees recursively.  */
 705         for (size_t i = 0; i < num_trees; i++)
 706                 for_dentry_in_tree(trees[i], dentry_append_to_list, dentry_list);
 707
 708         /* If requested, add ancestors of the trees.  */
 709         if (add_ancestors) {
 710                 for (size_t i = 0; i < num_trees; i++) {
 711                         struct wim_dentry *dentry = trees[i];
 712                         struct wim_dentry *ancestor;
 713                         struct list_head *place_after;
 714
 715                         if (dentry_is_root(dentry))
 716                                 continue;
 717
 718                         place_after = dentry_list;
 719                         ancestor = dentry;
 720                         do {
 721                                 ancestor = ancestor->d_parent;
 722                                 if (will_extract_dentry(ancestor)) {
 723                                         place_after = &ancestor->d_extraction_list_node;
 724                                         break;
 725                                 }
 726                         } while (!dentry_is_root(ancestor));
 727
 728                         ancestor = dentry;
 729                         do {
 730                                 ancestor = ancestor->d_parent;
 731                                 if (will_extract_dentry(ancestor))
 732                                         break;
 733                                 list_add(&ancestor->d_extraction_list_node, place_after);
 734                         } while (!dentry_is_root(ancestor));
 735                 }
 736         }
 737 }
 738
 739 static void
 740 destroy_dentry_list(struct list_head *dentry_list)
 741 {
 742         struct wim_dentry *dentry, *tmp;
 743         struct wim_inode *inode;
 744
 745         list_for_each_entry_safe(dentry, tmp, dentry_list, d_extraction_list_node) {
 746                 inode = dentry->d_inode;
 747                 dentry_reset_extraction_list_node(dentry);
 748                 inode->i_visited = 0;
 749                 inode->i_can_externally_back = 0;
 750                 if ((void *)dentry->d_extraction_name != (void *)dentry->d_name)
 751                         FREE(dentry->d_extraction_name);
 752                 dentry->d_extraction_name = NULL;
 753                 dentry->d_extraction_name_nchars = 0;
 754         }
 755 }
 756
 757 static void
 758 destroy_blob_list(struct list_head *blob_list)
 759 {
 760         struct blob_descriptor *blob;
 761
 762         list_for_each_entry(blob, blob_list, extraction_list)
 763                 if (blob->out_refcnt > ARRAY_LEN(blob->inline_blob_extraction_targets))
 764                         FREE(blob->blob_extraction_targets);
 765 }
 766
 767 #ifdef __WIN32__
 768 static const utf16lechar replacement_char = cpu_to_le16(0xfffd);
 769 #else
 770 static const utf16lechar replacement_char = cpu_to_le16('?');
 771 #endif
 772
 773 static bool
 774 file_name_valid(utf16lechar *name, size_t num_chars, bool fix)
 775 {
 776         size_t i;
 777
 778         if (num_chars == 0)
 779                 return true;
 780         for (i = 0; i < num_chars; i++) {
 781                 switch (le16_to_cpu(name[i])) {
 782         #ifdef __WIN32__
 783                 case '\x01'...'\x1F':
 784                 case '\\':
 785                 case ':':
 786                 case '*':
 787                 case '?':
 788                 case '"':
 789                 case '<':
 790                 case '>':
 791                 case '|':
 792         #endif
 793                 case '/':
 794                 case '\0':
 795                         if (fix)
 796                                 name[i] = replacement_char;
 797                         else
 798                                 return false;
 799                 }
 800         }
 801
 802         return true;
 803 }
 804
 805 static int
 806 dentry_calculate_extraction_name(struct wim_dentry *dentry,
 807                                  struct apply_ctx *ctx)
 808 {
 809         int ret;
 810
 811         if (dentry_is_root(dentry))
 812                 return 0;
 813
 814 #ifdef WITH_NTFS_3G
 815         if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
 816                 dentry->d_extraction_name = dentry->d_name;
 817                 dentry->d_extraction_name_nchars = dentry->d_name_nbytes /
 818                                                    sizeof(utf16lechar);
 819                 return 0;
 820         }
 821 #endif
 822
 823         if (!ctx->supported_features.case_sensitive_filenames) {
 824                 struct wim_dentry *other;
 825                 dentry_for_each_ci_match(other, dentry) {
 826                         if (will_extract_dentry(other)) {
 827                                 if (ctx->extract_flags &
 828                                     WIMLIB_EXTRACT_FLAG_ALL_CASE_CONFLICTS) {
 829                                         WARNING("\"%"TS"\" has the same "
 830                                                 "case-insensitive name as "
 831                                                 "\"%"TS"\"; extracting "
 832                                                 "dummy name instead",
 833                                                 dentry_full_path(dentry),
 834                                                 dentry_full_path(other));
 835                                         goto out_replace;
 836                                 } else {
 837                                         WARNING("Not extracting \"%"TS"\": "
 838                                                 "has same case-insensitive "
 839                                                 "name as \"%"TS"\"",
 840                                                 dentry_full_path(dentry),
 841                                                 dentry_full_path(other));
 842                                         goto skip_dentry;
 843                                 }
 844                         }
 845                 }
 846         }
 847
 848         if (file_name_valid(dentry->d_name, dentry->d_name_nbytes / 2, false)) {
 849                 size_t nbytes = 0;
 850                 ret = utf16le_get_tstr(dentry->d_name,
 851                                        dentry->d_name_nbytes,
 852                                        (const tchar **)&dentry->d_extraction_name,
 853                                        &nbytes);
 854                 dentry->d_extraction_name_nchars = nbytes / sizeof(tchar);
 855                 return ret;
 856         } else {
 857                 if (ctx->extract_flags & WIMLIB_EXTRACT_FLAG_REPLACE_INVALID_FILENAMES)
 858                 {
 859                         WARNING("\"%"TS"\" has an invalid filename "
 860                                 "that is not supported on this platform; "
 861                                 "extracting dummy name instead",
 862                                 dentry_full_path(dentry));
 863                         goto out_replace;
 864                 } else {
 865                         WARNING("Not extracting \"%"TS"\": has an invalid filename "
 866                                 "that is not supported on this platform",
 867                                 dentry_full_path(dentry));
 868                         goto skip_dentry;
 869                 }
 870         }
 871
 872 out_replace:
 873         {
 874                 utf16lechar utf16_name_copy[dentry->d_name_nbytes / 2];
 875
 876                 memcpy(utf16_name_copy, dentry->d_name, dentry->d_name_nbytes);
 877                 file_name_valid(utf16_name_copy, dentry->d_name_nbytes / 2, true);
 878
 879                 const tchar *tchar_name;
 880                 size_t tchar_nchars;
 881
 882                 ret = utf16le_get_tstr(utf16_name_copy,
 883                                        dentry->d_name_nbytes,
 884                                        &tchar_name, &tchar_nchars);
 885                 if (ret)
 886                         return ret;
 887
 888                 tchar_nchars /= sizeof(tchar);
 889
 890                 size_t fixed_name_num_chars = tchar_nchars;
 891                 tchar fixed_name[tchar_nchars + 50];
 892
 893                 tmemcpy(fixed_name, tchar_name, tchar_nchars);
 894                 fixed_name_num_chars += tsprintf(fixed_name + tchar_nchars,
 895                                                  T(" (invalid filename #%lu)"),
 896                                                  ++ctx->invalid_sequence);
 897
 898                 utf16le_put_tstr(tchar_name);
 899
 900                 dentry->d_extraction_name = TSTRDUP(fixed_name);
 901                 if (!dentry->d_extraction_name)
 902                         return WIMLIB_ERR_NOMEM;
 903                 dentry->d_extraction_name_nchars = fixed_name_num_chars;
 904         }
 905         return 0;
 906
 907 skip_dentry:
 908         for_dentry_in_tree(dentry, dentry_delete_from_list, NULL);
 909         return 0;
 910 }
 911
 912 /*
 913  * Calculate the actual filename component at which each WIM dentry will be
 914  * extracted, with special handling for dentries that are unsupported by the
 915  * extraction backend or have invalid names.
 916  *
 917  * ctx->supported_features must be filled in.
 918  *
 919  * Possible error codes: WIMLIB_ERR_NOMEM, WIMLIB_ERR_INVALID_UTF16_STRING
 920  */
 921 static int
 922 dentry_list_calculate_extraction_names(struct list_head *dentry_list,
 923                                        struct apply_ctx *ctx)
 924 {
 925         struct list_head *prev, *cur;
 926
 927         /* Can't use list_for_each_entry() because a call to
 928          * dentry_calculate_extraction_name() may delete the current dentry and
 929          * its children from the list.  */
 930
 931         prev = dentry_list;
 932         for (;;) {
 933                 struct wim_dentry *dentry;
 934                 int ret;
 935
 936                 cur = prev->next;
 937                 if (cur == dentry_list)
 938                         break;
 939
 940                 dentry = list_entry(cur, struct wim_dentry, d_extraction_list_node);
 941
 942                 ret = dentry_calculate_extraction_name(dentry, ctx);
 943                 if (ret)
 944                         return ret;
 945
 946                 if (prev->next == cur)
 947                         prev = cur;
 948                 else
 949                         ; /* Current dentry and its children (which follow in
 950                              the list) were deleted.  prev stays the same.  */
 951         }
 952         return 0;
 953 }
 954
 955 static int
 956 dentry_resolve_streams(struct wim_dentry *dentry, int extract_flags,
 957                        struct blob_table *blob_table)
 958 {
 959         struct wim_inode *inode = dentry->d_inode;
 960         struct blob_descriptor *blob;
 961         int ret;
 962         bool force = false;
 963
 964         /* Special case:  when extracting from a pipe, the WIM blob table is
 965          * initially empty, so "resolving" an inode's streams is initially not
 966          * possible.  However, we still need to keep track of which blobs,
 967          * identified by SHA-1 message digests, need to be extracted, so we
 968          * "resolve" the inode's streams anyway by allocating a 'struct
 969          * blob_descriptor' for each one.  */
 970         if (extract_flags & WIMLIB_EXTRACT_FLAG_FROM_PIPE)
 971                 force = true;
 972         ret = inode_resolve_streams(inode, blob_table, force);
 973         if (ret)
 974                 return ret;
 975         for (unsigned i = 0; i < inode->i_num_streams; i++) {
 976                 blob = stream_blob_resolved(&inode->i_streams[i]);
 977                 if (blob)
 978                         blob->out_refcnt = 0;
 979         }
 980         return 0;
 981 }
 982
 983 /*
 984  * For each dentry to be extracted, resolve all streams in the corresponding
 985  * inode and set 'out_refcnt' in all referenced blob_descriptors to 0.
 986  *
 987  * Possible error codes: WIMLIB_ERR_RESOURCE_NOT_FOUND, WIMLIB_ERR_NOMEM.
 988  */
 989 static int
 990 dentry_list_resolve_streams(struct list_head *dentry_list,
 991                             struct apply_ctx *ctx)
 992 {
 993         struct wim_dentry *dentry;
 994         int ret;
 995
 996         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 997                 ret = dentry_resolve_streams(dentry,
 998                                              ctx->extract_flags,
 999                                              ctx->wim->blob_table);
1000                 if (ret)
1001                         return ret;
1002         }
1003         return 0;
1004 }
1005
1006 static int
1007 ref_stream(struct wim_inode_stream *strm, struct wim_dentry *dentry,
1008            struct apply_ctx *ctx)
1009 {
1010         struct wim_inode *inode = dentry->d_inode;
1011         struct blob_descriptor *blob = stream_blob_resolved(strm);
1012         struct blob_extraction_target *targets;
1013
1014         if (!blob)
1015                 return 0;
1016
1017         /* Tally the size only for each actual extraction of the stream (not
1018          * additional hard links to the inode).  */
1019         if (inode->i_visited && ctx->supported_features.hard_links)
1020                 return 0;
1021
1022         ctx->progress.extract.total_bytes += blob->size;
1023         ctx->progress.extract.total_streams++;
1024
1025         if (inode->i_visited)
1026                 return 0;
1027
1028         /* Add each blob to 'ctx->blob_list' only one time, regardless of how
1029          * many extraction targets it will have.  */
1030         if (blob->out_refcnt == 0) {
1031                 list_add_tail(&blob->extraction_list, &ctx->blob_list);
1032                 ctx->num_blobs_remaining++;
1033         }
1034
1035         /* Set this stream as an extraction target of 'blob'.  */
1036
1037         if (blob->out_refcnt < ARRAY_LEN(blob->inline_blob_extraction_targets)) {
1038                 targets = blob->inline_blob_extraction_targets;
1039         } else {
1040                 struct blob_extraction_target *prev_targets;
1041                 size_t alloc_blob_extraction_targets;
1042
1043                 if (blob->out_refcnt == ARRAY_LEN(blob->inline_blob_extraction_targets)) {
1044                         prev_targets = NULL;
1045                         alloc_blob_extraction_targets = ARRAY_LEN(blob->inline_blob_extraction_targets);
1046                 } else {
1047                         prev_targets = blob->blob_extraction_targets;
1048                         alloc_blob_extraction_targets = blob->alloc_blob_extraction_targets;
1049                 }
1050
1051                 if (blob->out_refcnt == alloc_blob_extraction_targets) {
1052                         alloc_blob_extraction_targets *= 2;
1053                         targets = REALLOC(prev_targets,
1054                                           alloc_blob_extraction_targets *
1055                                           sizeof(targets[0]));
1056                         if (!targets)
1057                                 return WIMLIB_ERR_NOMEM;
1058                         if (!prev_targets) {
1059                                 memcpy(targets,
1060                                        blob->inline_blob_extraction_targets,
1061                                        sizeof(blob->inline_blob_extraction_targets));
1062                         }
1063                         blob->blob_extraction_targets = targets;
1064                         blob->alloc_blob_extraction_targets = alloc_blob_extraction_targets;
1065                 }
1066                 targets = blob->blob_extraction_targets;
1067         }
1068         targets[blob->out_refcnt].inode = inode;
1069         targets[blob->out_refcnt].stream = strm;
1070         blob->out_refcnt++;
1071         return 0;
1072 }
1073
1074 static int
1075 ref_stream_if_needed(struct wim_dentry *dentry, struct wim_inode *inode,
1076                      struct wim_inode_stream *strm, struct apply_ctx *ctx)
1077 {
1078         bool need_stream = false;
1079         switch (strm->stream_type) {
1080         case STREAM_TYPE_DATA:
1081                 if (stream_is_named(strm)) {
1082                         /* Named data stream  */
1083                         if (ctx->supported_features.named_data_streams)
1084                                 need_stream = true;
1085                 } else if (!(inode->i_attributes & (FILE_ATTRIBUTE_DIRECTORY |
1086                                                     FILE_ATTRIBUTE_ENCRYPTED))
1087                            && !(inode_is_symlink(inode)
1088                                 && !ctx->supported_features.reparse_points
1089                                 && ctx->supported_features.symlink_reparse_points))
1090                 {
1091                         /*
1092                          * Unnamed data stream.  Skip if any of the following is true:
1093                          *
1094                          * - file is a directory
1095                          * - file is encrypted
1096                          * - backend needs to create the file as UNIX symlink
1097                          * - backend will extract the stream as externally
1098                          *   backed from the WIM archive itself
1099                          */
1100                         if (ctx->apply_ops->will_back_from_wim) {
1101                                 int ret = (*ctx->apply_ops->will_back_from_wim)(dentry, ctx);
1102                                 if (ret > 0) /* Error?  */
1103                                         return ret;
1104                                 if (ret < 0) /* Won't externally back?  */
1105                                         need_stream = true;
1106                         } else {
1107                                 need_stream = true;
1108                         }
1109                 }
1110                 break;
1111         case STREAM_TYPE_REPARSE_POINT:
1112                 wimlib_assert(inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT);
1113                 if (ctx->supported_features.reparse_points ||
1114                     (inode_is_symlink(inode) &&
1115                      ctx->supported_features.symlink_reparse_points))
1116                         need_stream = true;
1117                 break;
1118         case STREAM_TYPE_EFSRPC_RAW_DATA:
1119                 wimlib_assert(inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED);
1120                 if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY) {
1121                         if (ctx->supported_features.encrypted_directories)
1122                                 need_stream = true;
1123                 } else {
1124                         if (ctx->supported_features.encrypted_files)
1125                                 need_stream = true;
1126                 }
1127                 break;
1128         }
1129         if (need_stream)
1130                 return ref_stream(strm, dentry, ctx);
1131         return 0;
1132 }
1133
1134 static int
1135 dentry_ref_streams(struct wim_dentry *dentry, struct apply_ctx *ctx)
1136 {
1137         struct wim_inode *inode = dentry->d_inode;
1138         for (unsigned i = 0; i < inode->i_num_streams; i++) {
1139                 int ret = ref_stream_if_needed(dentry, inode,
1140                                                &inode->i_streams[i], ctx);
1141                 if (ret)
1142                         return ret;
1143         }
1144         inode->i_visited = 1;
1145         return 0;
1146 }
1147
1148 /*
1149  * Given a list of dentries to be extracted, build the list of blobs that need
1150  * to be extracted, and for each blob determine the streams to which that blob
1151  * will be extracted.
1152  *
1153  * This also initializes the extract progress info with byte and blob
1154  * information.
1155  *
1156  * ctx->supported_features must be filled in.
1157  */
1158 static int
1159 dentry_list_ref_streams(struct list_head *dentry_list, struct apply_ctx *ctx)
1160 {
1161         struct wim_dentry *dentry;
1162         int ret;
1163
1164         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
1165                 ret = dentry_ref_streams(dentry, ctx);
1166                 if (ret)
1167                         return ret;
1168         }
1169         list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
1170                 dentry->d_inode->i_visited = 0;
1171         return 0;
1172 }
1173
1174 static void
1175 dentry_list_build_inode_alias_lists(struct list_head *dentry_list)
1176 {
1177         struct wim_dentry *dentry;
1178
1179         list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
1180                 dentry->d_inode->i_first_extraction_alias = NULL;
1181
1182         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
1183                 dentry->d_next_extraction_alias = dentry->d_inode->i_first_extraction_alias;
1184                 dentry->d_inode->i_first_extraction_alias = dentry;
1185         }
1186 }
1187
1188 static void
1189 inode_tally_features(const struct wim_inode *inode,
1190                      struct wim_features *features)
1191 {
1192         if (inode->i_attributes & FILE_ATTRIBUTE_READONLY)
1193                 features->readonly_files++;
1194         if (inode->i_attributes & FILE_ATTRIBUTE_HIDDEN)
1195                 features->hidden_files++;
1196         if (inode->i_attributes & FILE_ATTRIBUTE_SYSTEM)
1197                 features->system_files++;
1198         if (inode->i_attributes & FILE_ATTRIBUTE_ARCHIVE)
1199                 features->archive_files++;
1200         if (inode->i_attributes & FILE_ATTRIBUTE_COMPRESSED)
1201                 features->compressed_files++;
1202         if (inode->i_attributes & FILE_ATTRIBUTE_ENCRYPTED) {
1203                 if (inode->i_attributes & FILE_ATTRIBUTE_DIRECTORY)
1204                         features->encrypted_directories++;
1205                 else
1206                         features->encrypted_files++;
1207         }
1208         if (inode->i_attributes & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED)
1209                 features->not_context_indexed_files++;
1210         if (inode->i_attributes & FILE_ATTRIBUTE_SPARSE_FILE)
1211                 features->sparse_files++;
1212         if (inode_has_named_data_stream(inode))
1213                 features->named_data_streams++;
1214         if (inode->i_attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
1215                 features->reparse_points++;
1216                 if (inode_is_symlink(inode))
1217                         features->symlink_reparse_points++;
1218                 else
1219                         features->other_reparse_points++;
1220         }
1221         if (inode_has_security_descriptor(inode))
1222                 features->security_descriptors++;
1223         if (inode_has_unix_data(inode))
1224                 features->unix_data++;
1225         if (inode_has_object_id(inode))
1226                 features->object_ids++;
1227 }
1228
1229 /* Tally features necessary to extract a dentry and the corresponding inode.  */
1230 static void
1231 dentry_tally_features(struct wim_dentry *dentry, struct wim_features *features)
1232 {
1233         struct wim_inode *inode = dentry->d_inode;
1234
1235         if (dentry_has_short_name(dentry))
1236                 features->short_names++;
1237
1238         if (inode->i_visited) {
1239                 features->hard_links++;
1240         } else {
1241                 inode_tally_features(inode, features);
1242                 inode->i_visited = 1;
1243         }
1244 }
1245
1246 /* Tally the features necessary to extract the specified dentries.  */
1247 static void
1248 dentry_list_get_features(struct list_head *dentry_list,
1249                          struct wim_features *features)
1250 {
1251         struct wim_dentry *dentry;
1252
1253         list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
1254                 dentry_tally_features(dentry, features);
1255
1256         list_for_each_entry(dentry, dentry_list, d_extraction_list_node)
1257                 dentry->d_inode->i_visited = 0;
1258 }
1259
1260 static int
1261 do_feature_check(const struct wim_features *required_features,
1262                  const struct wim_features *supported_features,
1263                  int extract_flags)
1264 {
1265         /* Encrypted files.  */
1266         if (required_features->encrypted_files &&
1267             !supported_features->encrypted_files)
1268                 WARNING("Ignoring EFS-encrypted data of %lu files",
1269                         required_features->encrypted_files);
1270
1271         /* Named data streams.  */
1272         if (required_features->named_data_streams &&
1273             !supported_features->named_data_streams)
1274                 WARNING("Ignoring named data streams of %lu files",
1275                         required_features->named_data_streams);
1276
1277         /* File attributes.  */
1278         if (!(extract_flags & WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES)) {
1279
1280                 if (required_features->readonly_files &&
1281                     !supported_features->readonly_files)
1282                         WARNING("Ignoring FILE_ATTRIBUTE_READONLY of %lu files",
1283                                 required_features->readonly_files);
1284
1285                 if (required_features->hidden_files &&
1286                     !supported_features->hidden_files)
1287                         WARNING("Ignoring FILE_ATTRIBUTE_HIDDEN of %lu files",
1288                                 required_features->hidden_files);
1289
1290                 if (required_features->system_files &&
1291                     !supported_features->system_files)
1292                         WARNING("Ignoring FILE_ATTRIBUTE_SYSTEM of %lu files",
1293                                 required_features->system_files);
1294
1295                 /* Note: Don't bother the user about FILE_ATTRIBUTE_ARCHIVE.
1296                  * We're an archive program, so theoretically we can do what we
1297                  * want with it.  */
1298
1299                 if (required_features->compressed_files &&
1300                     !supported_features->compressed_files)
1301                         WARNING("Ignoring FILE_ATTRIBUTE_COMPRESSED of %lu files",
1302                                 required_features->compressed_files);
1303
1304                 if (required_features->not_context_indexed_files &&
1305                     !supported_features->not_context_indexed_files)
1306                         WARNING("Ignoring FILE_ATTRIBUTE_NOT_CONTENT_INDEXED of %lu files",
1307                                 required_features->not_context_indexed_files);
1308
1309                 if (required_features->sparse_files &&
1310                     !supported_features->sparse_files)
1311                         WARNING("Ignoring FILE_ATTRIBUTE_SPARSE_FILE of %lu files",
1312                                 required_features->sparse_files);
1313
1314                 if (required_features->encrypted_directories &&
1315                     !supported_features->encrypted_directories)
1316                         WARNING("Ignoring FILE_ATTRIBUTE_ENCRYPTED of %lu directories",
1317                                 required_features->encrypted_directories);
1318         }
1319
1320         /* Hard links.  */
1321         if (required_features->hard_links && !supported_features->hard_links)
1322                 WARNING("Extracting %lu hard links as independent files",
1323                         required_features->hard_links);
1324
1325         /* Symbolic links and reparse points.  */
1326         if ((extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS) &&
1327             required_features->symlink_reparse_points &&
1328             !supported_features->symlink_reparse_points &&
1329             !supported_features->reparse_points)
1330         {
1331                 ERROR("Extraction backend does not support symbolic links!");
1332                 return WIMLIB_ERR_UNSUPPORTED;
1333         }
1334         if (required_features->reparse_points &&
1335             !supported_features->reparse_points)
1336         {
1337                 if (supported_features->symlink_reparse_points) {
1338                         if (required_features->other_reparse_points) {
1339                                 WARNING("Ignoring reparse data of %lu non-symlink/junction files",
1340                                         required_features->other_reparse_points);
1341                         }
1342                 } else {
1343                         WARNING("Ignoring reparse data of %lu files",
1344                                 required_features->reparse_points);
1345                 }
1346         }
1347
1348         /* Security descriptors.  */
1349         if (((extract_flags & (WIMLIB_EXTRACT_FLAG_STRICT_ACLS |
1350                                WIMLIB_EXTRACT_FLAG_UNIX_DATA))
1351              == WIMLIB_EXTRACT_FLAG_STRICT_ACLS) &&
1352             required_features->security_descriptors &&
1353             !supported_features->security_descriptors)
1354         {
1355                 ERROR("Extraction backend does not support security descriptors!");
1356                 return WIMLIB_ERR_UNSUPPORTED;
1357         }
1358         if (!(extract_flags & WIMLIB_EXTRACT_FLAG_NO_ACLS) &&
1359             required_features->security_descriptors &&
1360             !supported_features->security_descriptors)
1361                 WARNING("Ignoring Windows NT security descriptors of %lu files",
1362                         required_features->security_descriptors);
1363
1364         /* UNIX data.  */
1365         if ((extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) &&
1366             required_features->unix_data && !supported_features->unix_data)
1367         {
1368                 ERROR("Extraction backend does not support UNIX data!");
1369                 return WIMLIB_ERR_UNSUPPORTED;
1370         }
1371
1372         if (required_features->unix_data &&
1373             !(extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA))
1374         {
1375                 WARNING("Ignoring UNIX metadata of %lu files",
1376                         required_features->unix_data);
1377         }
1378
1379         /* Object IDs.  */
1380         if (required_features->object_ids && !supported_features->object_ids) {
1381                 WARNING("Ignoring object IDs of %lu files",
1382                         required_features->object_ids);
1383         }
1384
1385         /* DOS Names.  */
1386         if (required_features->short_names &&
1387             !supported_features->short_names)
1388         {
1389                 if (extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES) {
1390                         ERROR("Extraction backend does not support DOS names!");
1391                         return WIMLIB_ERR_UNSUPPORTED;
1392                 }
1393                 WARNING("Ignoring DOS names of %lu files",
1394                         required_features->short_names);
1395         }
1396
1397         /* Timestamps.  */
1398         if ((extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS) &&
1399             !supported_features->timestamps)
1400         {
1401                 ERROR("Extraction backend does not support timestamps!");
1402                 return WIMLIB_ERR_UNSUPPORTED;
1403         }
1404
1405         return 0;
1406 }
1407
1408 static const struct apply_operations *
1409 select_apply_operations(int extract_flags)
1410 {
1411 #ifdef WITH_NTFS_3G
1412         if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS)
1413                 return &ntfs_3g_apply_ops;
1414 #endif
1415 #ifdef __WIN32__
1416         return &win32_apply_ops;
1417 #else
1418         return &unix_apply_ops;
1419 #endif
1420 }
1421
1422 static int
1423 extract_trees(WIMStruct *wim, struct wim_dentry **trees, size_t num_trees,
1424               const tchar *target, int extract_flags)
1425 {
1426         const struct apply_operations *ops;
1427         struct apply_ctx *ctx;
1428         int ret;
1429         LIST_HEAD(dentry_list);
1430
1431         if (extract_flags & WIMLIB_EXTRACT_FLAG_TO_STDOUT) {
1432                 ret = extract_dentries_to_stdout(trees, num_trees,
1433                                                  wim->blob_table);
1434                 goto out;
1435         }
1436
1437         num_trees = remove_duplicate_trees(trees, num_trees);
1438         num_trees = remove_contained_trees(trees, num_trees);
1439
1440         ops = select_apply_operations(extract_flags);
1441
1442         if (num_trees > 1 && ops->single_tree_only) {
1443                 ERROR("Extracting multiple directory trees "
1444                       "at once is not supported in %s extraction mode!",
1445                       ops->name);
1446                 ret = WIMLIB_ERR_UNSUPPORTED;
1447                 goto out;
1448         }
1449
1450         ctx = CALLOC(1, ops->context_size);
1451         if (!ctx) {
1452                 ret = WIMLIB_ERR_NOMEM;
1453                 goto out;
1454         }
1455
1456         ctx->wim = wim;
1457         ctx->target = target;
1458         ctx->target_nchars = tstrlen(target);
1459         ctx->extract_flags = extract_flags;
1460         if (ctx->wim->progfunc) {
1461                 ctx->progfunc = ctx->wim->progfunc;
1462                 ctx->progctx = ctx->wim->progctx;
1463                 ctx->progress.extract.image = wim->current_image;
1464                 ctx->progress.extract.extract_flags = (extract_flags &
1465                                                        WIMLIB_EXTRACT_MASK_PUBLIC);
1466                 ctx->progress.extract.wimfile_name = wim->filename;
1467                 ctx->progress.extract.image_name = wimlib_get_image_name(wim,
1468                                                                          wim->current_image);
1469                 ctx->progress.extract.target = target;
1470         }
1471         INIT_LIST_HEAD(&ctx->blob_list);
1472         filedes_invalidate(&ctx->tmpfile_fd);
1473         ctx->apply_ops = ops;
1474
1475         ret = (*ops->get_supported_features)(target, &ctx->supported_features);
1476         if (ret)
1477                 goto out_cleanup;
1478
1479         build_dentry_list(&dentry_list, trees, num_trees,
1480                           !(extract_flags &
1481                             WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE));
1482
1483         dentry_list_get_features(&dentry_list, &ctx->required_features);
1484
1485         ret = do_feature_check(&ctx->required_features, &ctx->supported_features,
1486                                ctx->extract_flags);
1487         if (ret)
1488                 goto out_cleanup;
1489
1490         ret = dentry_list_calculate_extraction_names(&dentry_list, ctx);
1491         if (ret)
1492                 goto out_cleanup;
1493
1494         if (unlikely(list_empty(&dentry_list))) {
1495                 WARNING("There is nothing to extract!");
1496                 goto out_cleanup;
1497         }
1498
1499         ret = dentry_list_resolve_streams(&dentry_list, ctx);
1500         if (ret)
1501                 goto out_cleanup;
1502
1503         dentry_list_build_inode_alias_lists(&dentry_list);
1504
1505         ret = dentry_list_ref_streams(&dentry_list, ctx);
1506         if (ret)
1507                 goto out_cleanup;
1508
1509         if (extract_flags & WIMLIB_EXTRACT_FLAG_FROM_PIPE) {
1510                 /* When extracting from a pipe, the number of bytes of data to
1511                  * extract can't be determined in the normal way (examining the
1512                  * blob table), since at this point all we have is a set of
1513                  * SHA-1 message digests of blobs that need to be extracted.
1514                  * However, we can get a reasonably accurate estimate by taking
1515                  * <TOTALBYTES> from the corresponding <IMAGE> in the WIM XML
1516                  * data.  This does assume that a full image is being extracted,
1517                  * but currently there is no API for doing otherwise.  (Also,
1518                  * subtract <HARDLINKBYTES> from this if hard links are
1519                  * supported by the extraction mode.)  */
1520                 ctx->progress.extract.total_bytes =
1521                         xml_get_image_total_bytes(wim->xml_info,
1522                                                   wim->current_image);
1523                 if (ctx->supported_features.hard_links) {
1524                         ctx->progress.extract.total_bytes -=
1525                                 xml_get_image_hard_link_bytes(wim->xml_info,
1526                                                               wim->current_image);
1527                 }
1528         }
1529
1530         ret = extract_progress(ctx,
1531                                ((extract_flags & WIMLIB_EXTRACT_FLAG_IMAGEMODE) ?
1532                                        WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN :
1533                                        WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN));
1534         if (ret)
1535                 goto out_cleanup;
1536
1537         ret = (*ops->extract)(&dentry_list, ctx);
1538         if (ret)
1539                 goto out_cleanup;
1540
1541         if (ctx->progress.extract.completed_bytes <
1542             ctx->progress.extract.total_bytes)
1543         {
1544                 ctx->progress.extract.completed_bytes =
1545                         ctx->progress.extract.total_bytes;
1546                 ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS);
1547                 if (ret)
1548                         goto out_cleanup;
1549         }
1550
1551         ret = extract_progress(ctx,
1552                                ((extract_flags & WIMLIB_EXTRACT_FLAG_IMAGEMODE) ?
1553                                        WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END :
1554                                        WIMLIB_PROGRESS_MSG_EXTRACT_TREE_END));
1555 out_cleanup:
1556         destroy_blob_list(&ctx->blob_list);
1557         destroy_dentry_list(&dentry_list);
1558         FREE(ctx);
1559 out:
1560         return ret;
1561 }
1562
1563 static int
1564 mkdir_if_needed(const tchar *target)
1565 {
1566         if (!tmkdir(target, 0755))
1567                 return 0;
1568
1569         if (errno == EEXIST)
1570                 return 0;
1571
1572 #ifdef __WIN32__
1573         /* _wmkdir() fails with EACCES if called on a drive root directory.  */
1574         if (errno == EACCES)
1575                 return 0;
1576 #endif
1577
1578         ERROR_WITH_ERRNO("Failed to create directory \"%"TS"\"", target);
1579         return WIMLIB_ERR_MKDIR;
1580 }
1581
1582 /* Make sure the extraction flags make sense, and update them if needed.  */
1583 static int
1584 check_extract_flags(const WIMStruct *wim, int *extract_flags_p)
1585 {
1586         int extract_flags = *extract_flags_p;
1587
1588         /* Check for invalid flag combinations  */
1589
1590         if ((extract_flags &
1591              (WIMLIB_EXTRACT_FLAG_NO_ACLS |
1592               WIMLIB_EXTRACT_FLAG_STRICT_ACLS)) == (WIMLIB_EXTRACT_FLAG_NO_ACLS |
1593                                                     WIMLIB_EXTRACT_FLAG_STRICT_ACLS))
1594                 return WIMLIB_ERR_INVALID_PARAM;
1595
1596         if ((extract_flags &
1597              (WIMLIB_EXTRACT_FLAG_RPFIX |
1598               WIMLIB_EXTRACT_FLAG_NORPFIX)) == (WIMLIB_EXTRACT_FLAG_RPFIX |
1599                                                 WIMLIB_EXTRACT_FLAG_NORPFIX))
1600                 return WIMLIB_ERR_INVALID_PARAM;
1601
1602 #ifndef WITH_NTFS_3G
1603         if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
1604                 ERROR("wimlib was compiled without support for NTFS-3G, so\n"
1605                       "        it cannot apply a WIM image directly to an NTFS volume.");
1606                 return WIMLIB_ERR_UNSUPPORTED;
1607         }
1608 #endif
1609
1610         if (extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT) {
1611 #ifdef __WIN32__
1612                 if (!wim->filename)
1613                         return WIMLIB_ERR_NO_FILENAME;
1614 #else
1615                 ERROR("WIMBoot extraction is only supported on Windows!");
1616                 return WIMLIB_ERR_UNSUPPORTED;
1617 #endif
1618         }
1619
1620         if (extract_flags & (WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K |
1621                              WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K |
1622                              WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K |
1623                              WIMLIB_EXTRACT_FLAG_COMPACT_LZX))
1624         {
1625         #ifdef __WIN32__
1626                 int count = 0;
1627                 count += ((extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K) != 0);
1628                 count += ((extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K) != 0);
1629                 count += ((extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K) != 0);
1630                 count += ((extract_flags & WIMLIB_EXTRACT_FLAG_COMPACT_LZX) != 0);
1631                 if (count != 1) {
1632                         ERROR("Only one compression format can be specified "
1633                               "for compact-mode extraction!");
1634                         return WIMLIB_ERR_INVALID_PARAM;
1635                 }
1636                 if (extract_flags & WIMLIB_EXTRACT_FLAG_WIMBOOT) {
1637                         ERROR("Compact-mode extraction and WIMBoot-mode "
1638                               "extraction are mutually exclusive!");
1639                         return WIMLIB_ERR_INVALID_PARAM;
1640                 }
1641         #else
1642                 ERROR("Compact-mode extraction (System Compression) "
1643                       "is only supported on Windows!");
1644                 return WIMLIB_ERR_UNSUPPORTED;
1645         #endif
1646         }
1647
1648
1649         if ((extract_flags & (WIMLIB_EXTRACT_FLAG_RPFIX |
1650                               WIMLIB_EXTRACT_FLAG_NORPFIX |
1651                               WIMLIB_EXTRACT_FLAG_IMAGEMODE)) ==
1652                                         WIMLIB_EXTRACT_FLAG_IMAGEMODE)
1653         {
1654                 /* For full-image extraction, do reparse point fixups by default
1655                  * if the WIM header says they are enabled.  */
1656                 if (wim->hdr.flags & WIM_HDR_FLAG_RP_FIX)
1657                         extract_flags |= WIMLIB_EXTRACT_FLAG_RPFIX;
1658         }
1659
1660         *extract_flags_p = extract_flags;
1661         return 0;
1662 }
1663
1664 struct append_dentry_ctx {
1665         struct wim_dentry **dentries;
1666         size_t num_dentries;
1667         size_t num_alloc_dentries;
1668 };
1669
1670 static int
1671 append_dentry_cb(struct wim_dentry *dentry, void *_ctx)
1672 {
1673         struct append_dentry_ctx *ctx = _ctx;
1674
1675         if (ctx->num_dentries == ctx->num_alloc_dentries) {
1676                 struct wim_dentry **new_dentries;
1677                 size_t new_length;
1678
1679                 new_length = max(ctx->num_alloc_dentries + 8,
1680                                  ctx->num_alloc_dentries * 3 / 2);
1681                 new_dentries = REALLOC(ctx->dentries,
1682                                        new_length * sizeof(ctx->dentries[0]));
1683                 if (new_dentries == NULL)
1684                         return WIMLIB_ERR_NOMEM;
1685                 ctx->dentries = new_dentries;
1686                 ctx->num_alloc_dentries = new_length;
1687         }
1688         ctx->dentries[ctx->num_dentries++] = dentry;
1689         return 0;
1690 }
1691
1692 /* Append dentries matched by a path which can contain wildcard characters.  */
1693 static int
1694 append_matched_dentries(WIMStruct *wim, const tchar *orig_pattern,
1695                         int extract_flags, struct append_dentry_ctx *ctx)
1696 {
1697         const size_t count_before = ctx->num_dentries;
1698         tchar *pattern;
1699         int ret;
1700
1701         pattern = canonicalize_wim_path(orig_pattern);
1702         if (!pattern)
1703                 return WIMLIB_ERR_NOMEM;
1704         ret = expand_path_pattern(wim_get_current_root_dentry(wim), pattern,
1705                                   append_dentry_cb, ctx);
1706         FREE(pattern);
1707         if (ret || ctx->num_dentries > count_before)
1708                 return ret;
1709         if (extract_flags & WIMLIB_EXTRACT_FLAG_STRICT_GLOB) {
1710                 ERROR("No matches for path pattern \"%"TS"\"", orig_pattern);
1711                 return WIMLIB_ERR_PATH_DOES_NOT_EXIST;
1712         }
1713         WARNING("No matches for path pattern \"%"TS"\"", orig_pattern);
1714         return 0;
1715 }
1716
1717 static int
1718 do_wimlib_extract_paths(WIMStruct *wim, int image, const tchar *target,
1719                         const tchar * const *paths, size_t num_paths,
1720                         int extract_flags)
1721 {
1722         int ret;
1723         struct wim_dentry **trees;
1724         size_t num_trees;
1725
1726         if (wim == NULL || target == NULL || target[0] == T('\0') ||
1727             (num_paths != 0 && paths == NULL))
1728                 return WIMLIB_ERR_INVALID_PARAM;
1729
1730         ret = check_extract_flags(wim, &extract_flags);
1731         if (ret)
1732                 return ret;
1733
1734         ret = select_wim_image(wim, image);
1735         if (ret)
1736                 return ret;
1737
1738         ret = wim_checksum_unhashed_blobs(wim);
1739         if (ret)
1740                 return ret;
1741
1742         if ((extract_flags & (WIMLIB_EXTRACT_FLAG_NTFS |
1743                               WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE)) ==
1744             (WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE))
1745         {
1746                 ret = mkdir_if_needed(target);
1747                 if (ret)
1748                         return ret;
1749         }
1750
1751         if (extract_flags & WIMLIB_EXTRACT_FLAG_GLOB_PATHS) {
1752
1753                 struct append_dentry_ctx append_dentry_ctx = {
1754                         .dentries = NULL,
1755                         .num_dentries = 0,
1756                         .num_alloc_dentries = 0,
1757                 };
1758
1759                 for (size_t i = 0; i < num_paths; i++) {
1760                         ret = append_matched_dentries(wim, paths[i],
1761                                                       extract_flags,
1762                                                       &append_dentry_ctx);
1763                         if (ret) {
1764                                 trees = append_dentry_ctx.dentries;
1765                                 goto out_free_trees;
1766                         }
1767                 }
1768                 trees = append_dentry_ctx.dentries;
1769                 num_trees = append_dentry_ctx.num_dentries;
1770         } else {
1771                 trees = MALLOC(num_paths * sizeof(trees[0]));
1772                 if (trees == NULL)
1773                         return WIMLIB_ERR_NOMEM;
1774
1775                 for (size_t i = 0; i < num_paths; i++) {
1776
1777                         tchar *path = canonicalize_wim_path(paths[i]);
1778                         if (path == NULL) {
1779                                 ret = WIMLIB_ERR_NOMEM;
1780                                 goto out_free_trees;
1781                         }
1782
1783                         trees[i] = get_dentry(wim, path,
1784                                               WIMLIB_CASE_PLATFORM_DEFAULT);
1785                         FREE(path);
1786                         if (trees[i] == NULL) {
1787                                   ERROR("Path \"%"TS"\" does not exist "
1788                                         "in WIM image %d",
1789                                         paths[i], wim->current_image);
1790                                   ret = WIMLIB_ERR_PATH_DOES_NOT_EXIST;
1791                                   goto out_free_trees;
1792                         }
1793                 }
1794                 num_trees = num_paths;
1795         }
1796
1797         if (num_trees == 0) {
1798                 ret = 0;
1799                 goto out_free_trees;
1800         }
1801
1802         ret = extract_trees(wim, trees, num_trees, target, extract_flags);
1803 out_free_trees:
1804         FREE(trees);
1805         return ret;
1806 }
1807
1808 static int
1809 extract_single_image(WIMStruct *wim, int image,
1810                      const tchar *target, int extract_flags)
1811 {
1812         const tchar *path = WIMLIB_WIM_ROOT_PATH;
1813         extract_flags |= WIMLIB_EXTRACT_FLAG_IMAGEMODE;
1814         return do_wimlib_extract_paths(wim, image, target, &path, 1, extract_flags);
1815 }
1816
1817 static const tchar * const filename_forbidden_chars =
1818 #ifdef __WIN32__
1819 T("<>:\"/\\|?*");
1820 #else
1821 T("/");
1822 #endif
1823
1824 /* This function checks if it is okay to use a WIM image's name as a directory
1825  * name.  */
1826 static bool
1827 image_name_ok_as_dir(const tchar *image_name)
1828 {
1829         return image_name && *image_name &&
1830                 !tstrpbrk(image_name, filename_forbidden_chars) &&
1831                 tstrcmp(image_name, T(".")) &&
1832                 tstrcmp(image_name, T("..")) &&
1833                 tstrlen(image_name) <= 128;
1834 }
1835
1836 /* Extracts all images from the WIM to the directory @target, with the images
1837  * placed in subdirectories named by their image names. */
1838 static int
1839 extract_all_images(WIMStruct *wim, const tchar *target, int extract_flags)
1840 {
1841         size_t output_path_len = tstrlen(target);
1842         tchar buf[output_path_len + 1 + 128 + 1];
1843         int ret;
1844         int image;
1845         const tchar *image_name;
1846
1847         if (extract_flags & WIMLIB_EXTRACT_FLAG_NTFS) {
1848                 ERROR("Cannot extract multiple images in NTFS extraction mode.");
1849                 return WIMLIB_ERR_INVALID_PARAM;
1850         }
1851
1852         ret = mkdir_if_needed(target);
1853         if (ret)
1854                 return ret;
1855         tmemcpy(buf, target, output_path_len);
1856         buf[output_path_len] = OS_PREFERRED_PATH_SEPARATOR;
1857         for (image = 1; image <= wim->hdr.image_count; image++) {
1858                 image_name = wimlib_get_image_name(wim, image);
1859                 if (image_name_ok_as_dir(image_name)) {
1860                         tstrcpy(buf + output_path_len + 1, image_name);
1861                 } else {
1862                         /* Image name is empty or contains forbidden characters.
1863                          * Use image number instead. */
1864                         tsprintf(buf + output_path_len + 1, T("%d"), image);
1865                 }
1866                 ret = extract_single_image(wim, image, buf, extract_flags);
1867                 if (ret)
1868                         return ret;
1869         }
1870         return 0;
1871 }
1872
1873 static int
1874 do_wimlib_extract_image(WIMStruct *wim, int image, const tchar *target,
1875                         int extract_flags)
1876 {
1877         if (extract_flags & (WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE |
1878                              WIMLIB_EXTRACT_FLAG_TO_STDOUT |
1879                              WIMLIB_EXTRACT_FLAG_GLOB_PATHS))
1880                 return WIMLIB_ERR_INVALID_PARAM;
1881
1882         if (image == WIMLIB_ALL_IMAGES)
1883                 return extract_all_images(wim, target, extract_flags);
1884         else
1885                 return extract_single_image(wim, image, target, extract_flags);
1886 }
1887
1888
1889 /****************************************************************************
1890  *                          Extraction API                                  *
1891  ****************************************************************************/
1892
1893 WIMLIBAPI int
1894 wimlib_extract_paths(WIMStruct *wim, int image, const tchar *target,
1895                      const tchar * const *paths, size_t num_paths,
1896                      int extract_flags)
1897 {
1898         if (extract_flags & ~WIMLIB_EXTRACT_MASK_PUBLIC)
1899                 return WIMLIB_ERR_INVALID_PARAM;
1900
1901         return do_wimlib_extract_paths(wim, image, target, paths, num_paths,
1902                                        extract_flags);
1903 }
1904
1905 WIMLIBAPI int
1906 wimlib_extract_pathlist(WIMStruct *wim, int image, const tchar *target,
1907                         const tchar *path_list_file, int extract_flags)
1908 {
1909         int ret;
1910         tchar **paths;
1911         size_t num_paths;
1912         void *mem;
1913
1914         ret = read_path_list_file(path_list_file, &paths, &num_paths, &mem);
1915         if (ret) {
1916                 ERROR("Failed to read path list file \"%"TS"\"",
1917                       path_list_file);
1918                 return ret;
1919         }
1920
1921         ret = wimlib_extract_paths(wim, image, target,
1922                                    (const tchar * const *)paths, num_paths,
1923                                    extract_flags);
1924         FREE(paths);
1925         FREE(mem);
1926         return ret;
1927 }
1928
1929 WIMLIBAPI int
1930 wimlib_extract_image_from_pipe_with_progress(int pipe_fd,
1931                                              const tchar *image_num_or_name,
1932                                              const tchar *target,
1933                                              int extract_flags,
1934                                              wimlib_progress_func_t progfunc,
1935                                              void *progctx)
1936 {
1937         int ret;
1938         WIMStruct *pwm;
1939         struct filedes *in_fd;
1940         int image;
1941         unsigned i;
1942
1943         if (extract_flags & ~WIMLIB_EXTRACT_MASK_PUBLIC)
1944                 return WIMLIB_ERR_INVALID_PARAM;
1945
1946         /* Read the WIM header from the pipe and get a WIMStruct to represent
1947          * the pipable WIM.  Caveats:  Unlike getting a WIMStruct with
1948          * wimlib_open_wim(), getting a WIMStruct in this way will result in an
1949          * empty blob table, no XML data read, and no filename set.  */
1950         ret = open_wim_as_WIMStruct(&pipe_fd, WIMLIB_OPEN_FLAG_FROM_PIPE, &pwm,
1951                                     progfunc, progctx);
1952         if (ret)
1953                 return ret;
1954
1955         /* Sanity check to make sure this is a pipable WIM.  */
1956         if (pwm->hdr.magic != PWM_MAGIC) {
1957                 ERROR("The WIM being read from file descriptor %d "
1958                       "is not pipable!", pipe_fd);
1959                 ret = WIMLIB_ERR_NOT_PIPABLE;
1960                 goto out_wimlib_free;
1961         }
1962
1963         /* Sanity check to make sure the first part of a pipable split WIM is
1964          * sent over the pipe first.  */
1965         if (pwm->hdr.part_number != 1) {
1966                 ERROR("The first part of the split WIM must be "
1967                       "sent over the pipe first.");
1968                 ret = WIMLIB_ERR_INVALID_PIPABLE_WIM;
1969                 goto out_wimlib_free;
1970         }
1971
1972         in_fd = &pwm->in_fd;
1973         wimlib_assert(in_fd->offset == WIM_HEADER_DISK_SIZE);
1974
1975         /* As mentioned, the WIMStruct we created from the pipe does not have
1976          * XML data yet.  Fix this by reading the extra copy of the XML data
1977          * that directly follows the header in pipable WIMs.  (Note: see
1978          * write_pipable_wim() for more details about the format of pipable
1979          * WIMs.)  */
1980         {
1981                 u8 hash[SHA1_HASH_SIZE];
1982
1983                 ret = read_pwm_blob_header(pwm, hash,
1984                                            &pwm->hdr.xml_data_reshdr, NULL);
1985                 if (ret)
1986                         goto out_wimlib_free;
1987
1988                 if (!(pwm->hdr.xml_data_reshdr.flags & WIM_RESHDR_FLAG_METADATA)) {
1989                         ERROR("Expected XML data, but found non-metadata resource.");
1990                         ret = WIMLIB_ERR_INVALID_PIPABLE_WIM;
1991                         goto out_wimlib_free;
1992                 }
1993
1994                 ret = read_wim_xml_data(pwm);
1995                 if (ret)
1996                         goto out_wimlib_free;
1997
1998                 if (xml_get_image_count(pwm->xml_info) != pwm->hdr.image_count) {
1999                         ERROR("Image count in XML data is not the same as in WIM header.");
2000                         ret = WIMLIB_ERR_IMAGE_COUNT;
2001                         goto out_wimlib_free;
2002                 }
2003         }
2004
2005         /* Get image index (this may use the XML data that was just read to
2006          * resolve an image name).  */
2007         if (image_num_or_name) {
2008                 image = wimlib_resolve_image(pwm, image_num_or_name);
2009                 if (image == WIMLIB_NO_IMAGE) {
2010                         ERROR("\"%"TS"\" is not a valid image in the pipable WIM!",
2011                               image_num_or_name);
2012                         ret = WIMLIB_ERR_INVALID_IMAGE;
2013                         goto out_wimlib_free;
2014                 } else if (image == WIMLIB_ALL_IMAGES) {
2015                         ERROR("Applying all images from a pipe is not supported!");
2016                         ret = WIMLIB_ERR_INVALID_IMAGE;
2017                         goto out_wimlib_free;
2018                 }
2019         } else {
2020                 if (pwm->hdr.image_count != 1) {
2021                         ERROR("No image was specified, but the pipable WIM "
2022                               "did not contain exactly 1 image");
2023                         ret = WIMLIB_ERR_INVALID_IMAGE;
2024                         goto out_wimlib_free;
2025                 }
2026                 image = 1;
2027         }
2028
2029         /* Load the needed metadata resource.  */
2030         for (i = 1; i <= pwm->hdr.image_count; i++) {
2031                 ret = handle_pwm_metadata_resource(pwm, i, i == image);
2032                 if (ret)
2033                         goto out_wimlib_free;
2034         }
2035         /* Extract the image.  */
2036         extract_flags |= WIMLIB_EXTRACT_FLAG_FROM_PIPE;
2037         ret = do_wimlib_extract_image(pwm, image, target, extract_flags);
2038         /* Clean up and return.  */
2039 out_wimlib_free:
2040         wimlib_free(pwm);
2041         return ret;
2042 }
2043
2044
2045 WIMLIBAPI int
2046 wimlib_extract_image_from_pipe(int pipe_fd, const tchar *image_num_or_name,
2047                                const tchar *target, int extract_flags)
2048 {
2049         return wimlib_extract_image_from_pipe_with_progress(pipe_fd,
2050                                                             image_num_or_name,
2051                                                             target,
2052                                                             extract_flags,
2053                                                             NULL,
2054                                                             NULL);
2055 }
2056
2057 WIMLIBAPI int
2058 wimlib_extract_image(WIMStruct *wim, int image, const tchar *target,
2059                      int extract_flags)
2060 {
2061         if (extract_flags & ~WIMLIB_EXTRACT_MASK_PUBLIC)
2062                 return WIMLIB_ERR_INVALID_PARAM;
2063         return do_wimlib_extract_image(wim, image, target, extract_flags);
2064 }