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

   1 /*
   2  * unix_apply.c - Code to apply files from a WIM image on UNIX.
   3  */
   4
   5 /*
   6  * Copyright (C) 2012, 2013, 2014 Eric Biggers
   7  *
   8  * This file is free software; you can redistribute it and/or modify it under
   9  * the terms of the GNU Lesser General Public License as published by the Free
  10  * Software Foundation; either version 3 of the License, or (at your option) any
  11  * later version.
  12  *
  13  * This file is distributed in the hope that it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this file; if not, see http://www.gnu.org/licenses/.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #  include "config.h"
  24 #endif
  25
  26 #include "wimlib/apply.h"
  27 #include "wimlib/assert.h"
  28 #include "wimlib/dentry.h"
  29 #include "wimlib/error.h"
  30 #include "wimlib/file_io.h"
  31 #include "wimlib/reparse.h"
  32 #include "wimlib/timestamp.h"
  33 #include "wimlib/unix_data.h"
  34
  35 #include <errno.h>
  36 #include <fcntl.h>
  37 #include <limits.h>
  38 #include <stdlib.h>
  39 #include <sys/stat.h>
  40 #include <sys/time.h>
  41 #include <sys/types.h>
  42 #include <unistd.h>
  43
  44 /* We don't require O_NOFOLLOW, but the advantage of having it is that if we
  45  * need to extract a file to a location at which there exists a symbolic link,
  46  * open(..., O_NOFOLLOW | ...) recognizes the symbolic link rather than
  47  * following it and creating the file somewhere else.  (Equivalent to
  48  * FILE_OPEN_REPARSE_POINT on Windows.)  */
  49 #ifndef O_NOFOLLOW
  50 #  define O_NOFOLLOW 0
  51 #endif
  52
  53 static int
  54 unix_get_supported_features(const char *target,
  55                             struct wim_features *supported_features)
  56 {
  57         supported_features->hard_links = 1;
  58         supported_features->symlink_reparse_points = 1;
  59         supported_features->unix_data = 1;
  60         supported_features->timestamps = 1;
  61         supported_features->case_sensitive_filenames = 1;
  62         return 0;
  63 }
  64
  65 #define NUM_PATHBUFS 2  /* We need 2 when creating hard links  */
  66
  67 struct unix_apply_ctx {
  68         /* Extract flags, the pointer to the WIMStruct, etc.  */
  69         struct apply_ctx common;
  70
  71         /* Buffers for building extraction paths (allocated).  */
  72         char *pathbufs[NUM_PATHBUFS];
  73
  74         /* Index of next pathbuf to use  */
  75         unsigned which_pathbuf;
  76
  77         /* Currently open file descriptors for extraction  */
  78         struct filedes open_fds[MAX_OPEN_STREAMS];
  79
  80         /* Number of currently open file descriptors in open_fds, starting from
  81          * the beginning of the array.  */
  82         unsigned num_open_fds;
  83
  84         /* Buffer for reading reparse data streams into memory  */
  85         u8 reparse_data[REPARSE_DATA_MAX_SIZE];
  86
  87         /* Pointer to the next byte in @reparse_data to fill  */
  88         u8 *reparse_ptr;
  89
  90         /* Absolute path to the target directory (allocated buffer).  Only set
  91          * if needed for absolute symbolic link fixups.  */
  92         char *target_abspath;
  93
  94         /* Number of characters in target_abspath.  */
  95         size_t target_abspath_nchars;
  96
  97         /* Number of special files we couldn't create due to EPERM  */
  98         unsigned long num_special_files_ignored;
  99 };
 100
 101 /* Returns the number of characters needed to represent the path to the
 102  * specified @dentry when extracted, not including the null terminator or the
 103  * path to the target directory itself.  */
 104 static size_t
 105 unix_dentry_path_length(const struct wim_dentry *dentry)
 106 {
 107         size_t len = 0;
 108         const struct wim_dentry *d;
 109
 110         d = dentry;
 111         do {
 112                 len += d->d_extraction_name_nchars + 1;
 113                 d = d->d_parent;
 114         } while (!dentry_is_root(d) && will_extract_dentry(d));
 115
 116         return len;
 117 }
 118
 119 /* Returns the maximum number of characters needed to represent the path to any
 120  * dentry in @dentry_list when extracted, including the null terminator and the
 121  * path to the target directory itself.  */
 122 static size_t
 123 unix_compute_path_max(const struct list_head *dentry_list,
 124                       const struct unix_apply_ctx *ctx)
 125 {
 126         size_t max = 0;
 127         size_t len;
 128         const struct wim_dentry *dentry;
 129
 130         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 131                 len = unix_dentry_path_length(dentry);
 132                 if (len > max)
 133                         max = len;
 134         }
 135
 136         /* Account for target and null terminator.  */
 137         return ctx->common.target_nchars + max + 1;
 138 }
 139
 140 /* Builds and returns the filesystem path to which to extract @dentry.
 141  * This cycles through NUM_PATHBUFS different buffers.  */
 142 static const char *
 143 unix_build_extraction_path(const struct wim_dentry *dentry,
 144                            struct unix_apply_ctx *ctx)
 145 {
 146         char *pathbuf;
 147         char *p;
 148         const struct wim_dentry *d;
 149
 150         pathbuf = ctx->pathbufs[ctx->which_pathbuf];
 151         ctx->which_pathbuf = (ctx->which_pathbuf + 1) % NUM_PATHBUFS;
 152
 153         p = &pathbuf[ctx->common.target_nchars +
 154                      unix_dentry_path_length(dentry)];
 155         *p = '\0';
 156         d = dentry;
 157         do {
 158                 p -= d->d_extraction_name_nchars;
 159                 memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
 160                 *--p = '/';
 161                 d = d->d_parent;
 162         } while (!dentry_is_root(d) && will_extract_dentry(d));
 163
 164         return pathbuf;
 165 }
 166
 167 /* This causes the next call to unix_build_extraction_path() to use the same
 168  * path buffer as the previous call.  */
 169 static void
 170 unix_reuse_pathbuf(struct unix_apply_ctx *ctx)
 171 {
 172         ctx->which_pathbuf = (ctx->which_pathbuf - 1) % NUM_PATHBUFS;
 173 }
 174
 175 /* Builds and returns the filesystem path to which to extract an unspecified
 176  * alias of the @inode.  This cycles through NUM_PATHBUFS different buffers.  */
 177 static const char *
 178 unix_build_inode_extraction_path(const struct wim_inode *inode,
 179                                  struct unix_apply_ctx *ctx)
 180 {
 181         return unix_build_extraction_path(inode_first_extraction_dentry(inode), ctx);
 182 }
 183
 184 /* Sets the timestamps on a file being extracted.
 185  *
 186  * Either @fd or @path must be specified (not -1 and not NULL, respectively).
 187  */
 188 static int
 189 unix_set_timestamps(int fd, const char *path, u64 atime, u64 mtime)
 190 {
 191         {
 192                 struct timespec times[2];
 193
 194                 times[0] = wim_timestamp_to_timespec(atime);
 195                 times[1] = wim_timestamp_to_timespec(mtime);
 196
 197                 errno = ENOSYS;
 198 #ifdef HAVE_FUTIMENS
 199                 if (fd >= 0 && !futimens(fd, times))
 200                         return 0;
 201 #endif
 202 #ifdef HAVE_UTIMENSAT
 203                 if (fd < 0 && !utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW))
 204                         return 0;
 205 #endif
 206                 if (errno != ENOSYS)
 207                         return WIMLIB_ERR_SET_TIMESTAMPS;
 208         }
 209         {
 210                 struct timeval times[2];
 211
 212                 times[0] = wim_timestamp_to_timeval(atime);
 213                 times[1] = wim_timestamp_to_timeval(mtime);
 214
 215                 if (fd >= 0 && !futimes(fd, times))
 216                         return 0;
 217                 if (fd < 0 && !lutimes(path, times))
 218                         return 0;
 219                 return WIMLIB_ERR_SET_TIMESTAMPS;
 220         }
 221 }
 222
 223 static int
 224 unix_set_owner_and_group(int fd, const char *path, uid_t uid, gid_t gid)
 225 {
 226         if (fd >= 0 && !fchown(fd, uid, gid))
 227                 return 0;
 228         if (fd < 0 && !lchown(path, uid, gid))
 229                 return 0;
 230         return WIMLIB_ERR_SET_SECURITY;
 231 }
 232
 233 static int
 234 unix_set_mode(int fd, const char *path, mode_t mode)
 235 {
 236         if (fd >= 0 && !fchmod(fd, mode))
 237                 return 0;
 238         if (fd < 0 && !chmod(path, mode))
 239                 return 0;
 240         return WIMLIB_ERR_SET_SECURITY;
 241 }
 242
 243 /*
 244  * Set metadata on an extracted file.
 245  *
 246  * @fd is an open file descriptor to the extracted file, or -1.  @path is the
 247  * path to the extracted file, or NULL.  If valid, this function uses @fd.
 248  * Otherwise, if valid, it uses @path.  Otherwise, it calculates the path to one
 249  * alias of the extracted file and uses it.
 250  */
 251 static int
 252 unix_set_metadata(int fd, const struct wim_inode *inode,
 253                   const char *path, struct unix_apply_ctx *ctx)
 254 {
 255         int ret;
 256         struct wimlib_unix_data unix_data;
 257
 258         if (fd < 0 && !path)
 259                 path = unix_build_inode_extraction_path(inode, ctx);
 260
 261         if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA)
 262             && inode_get_unix_data(inode, &unix_data))
 263         {
 264                 u32 uid = unix_data.uid;
 265                 u32 gid = unix_data.gid;
 266                 u32 mode = unix_data.mode;
 267
 268                 ret = unix_set_owner_and_group(fd, path, uid, gid);
 269                 if (ret) {
 270                         if (!path)
 271                                 path = unix_build_inode_extraction_path(inode, ctx);
 272                         if (ctx->common.extract_flags &
 273                             WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
 274                         {
 275                                 ERROR_WITH_ERRNO("Can't set uid=%"PRIu32" and "
 276                                                  "gid=%"PRIu32" on \"%s\"",
 277                                                  uid, gid, path);
 278                                 return ret;
 279                         } else {
 280                                 WARNING_WITH_ERRNO("Can't set uid=%"PRIu32" and "
 281                                                    "gid=%"PRIu32" on \"%s\"",
 282                                                    uid, gid, path);
 283                         }
 284                 }
 285
 286                 ret = 0;
 287                 if (!inode_is_symlink(inode))
 288                         ret = unix_set_mode(fd, path, mode);
 289                 if (ret) {
 290                         if (!path)
 291                                 path = unix_build_inode_extraction_path(inode, ctx);
 292                         if (ctx->common.extract_flags &
 293                             WIMLIB_EXTRACT_FLAG_STRICT_ACLS)
 294                         {
 295                                 ERROR_WITH_ERRNO("Can't set mode=0%"PRIo32" "
 296                                                  "on \"%s\"", mode, path);
 297                                 return ret;
 298                         } else {
 299                                 WARNING_WITH_ERRNO("Can't set mode=0%"PRIo32" "
 300                                                    "on \"%s\"", mode, path);
 301                         }
 302                 }
 303         }
 304
 305         ret = unix_set_timestamps(fd, path,
 306                                   inode->i_last_access_time,
 307                                   inode->i_last_write_time);
 308         if (ret) {
 309                 if (!path)
 310                         path = unix_build_inode_extraction_path(inode, ctx);
 311                 if (ctx->common.extract_flags &
 312                     WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS)
 313                 {
 314                         ERROR_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
 315                         return ret;
 316                 } else {
 317                         WARNING_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
 318                 }
 319         }
 320         return 0;
 321 }
 322
 323 /* Extract all needed aliases of the @inode, where one alias, corresponding to
 324  * @first_dentry, has already been extracted to @first_path.  */
 325 static int
 326 unix_create_hardlinks(const struct wim_inode *inode,
 327                       const struct wim_dentry *first_dentry,
 328                       const char *first_path, struct unix_apply_ctx *ctx)
 329 {
 330         const struct wim_dentry *dentry;
 331         const char *newpath;
 332
 333         list_for_each_entry(dentry, &inode->i_extraction_aliases,
 334                             d_extraction_alias_node)
 335         {
 336                 if (dentry == first_dentry)
 337                         continue;
 338
 339                 newpath = unix_build_extraction_path(dentry, ctx);
 340         retry_link:
 341                 if (link(first_path, newpath)) {
 342                         if (errno == EEXIST && !unlink(newpath))
 343                                 goto retry_link;
 344                         ERROR_WITH_ERRNO("Can't create hard link "
 345                                          "\"%s\" => \"%s\"", newpath, first_path);
 346                         return WIMLIB_ERR_LINK;
 347                 }
 348                 unix_reuse_pathbuf(ctx);
 349         }
 350         return 0;
 351 }
 352
 353 /* If @dentry represents a directory, create it.  */
 354 static int
 355 unix_create_if_directory(const struct wim_dentry *dentry,
 356                          struct unix_apply_ctx *ctx)
 357 {
 358         const char *path;
 359         struct stat stbuf;
 360
 361         if (!dentry_is_directory(dentry))
 362                 return 0;
 363
 364         path = unix_build_extraction_path(dentry, ctx);
 365         if (mkdir(path, 0755) &&
 366             /* It's okay if the path already exists, as long as it's a
 367              * directory.  */
 368             !(errno == EEXIST && !lstat(path, &stbuf) && S_ISDIR(stbuf.st_mode)))
 369         {
 370                 ERROR_WITH_ERRNO("Can't create directory \"%s\"", path);
 371                 return WIMLIB_ERR_MKDIR;
 372         }
 373
 374         return report_file_created(&ctx->common);
 375 }
 376
 377 /* If @dentry represents an empty regular file or a special file, create it, set
 378  * its metadata, and create any needed hard links.  */
 379 static int
 380 unix_extract_if_empty_file(const struct wim_dentry *dentry,
 381                            struct unix_apply_ctx *ctx)
 382 {
 383         const struct wim_inode *inode;
 384         struct wimlib_unix_data unix_data;
 385         const char *path;
 386         int ret;
 387
 388         inode = dentry->d_inode;
 389
 390         /* Extract all aliases only when the "first" comes up.  */
 391         if (dentry != inode_first_extraction_dentry(inode))
 392                 return 0;
 393
 394         /* Is this a directory, a symbolic link, or any type of nonempty file?
 395          */
 396         if (inode_is_directory(inode) || inode_is_symlink(inode) ||
 397             inode_unnamed_lte_resolved(inode))
 398                 return 0;
 399
 400         /* Recognize special files in UNIX_DATA mode  */
 401         if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_UNIX_DATA) &&
 402             inode_get_unix_data(inode, &unix_data) &&
 403             !S_ISREG(unix_data.mode))
 404         {
 405                 path = unix_build_extraction_path(dentry, ctx);
 406         retry_mknod:
 407                 if (mknod(path, unix_data.mode, unix_data.rdev)) {
 408                         if (errno == EPERM) {
 409                                 WARNING_WITH_ERRNO("Can't create special "
 410                                                    "file \"%s\"", path);
 411                                 ctx->num_special_files_ignored++;
 412                                 return 0;
 413                         }
 414                         if (errno == EEXIST && !unlink(path))
 415                                 goto retry_mknod;
 416                         ERROR_WITH_ERRNO("Can't create special file \"%s\"",
 417                                          path);
 418                         return WIMLIB_ERR_MKNOD;
 419                 }
 420                 /* On special files, we can set timestamps immediately because
 421                  * we don't need to write any data to them.  */
 422                 ret = unix_set_metadata(-1, inode, path, ctx);
 423         } else {
 424                 int fd;
 425
 426                 path = unix_build_extraction_path(dentry, ctx);
 427         retry_create:
 428                 fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
 429                 if (fd < 0) {
 430                         if (errno == EEXIST && !unlink(path))
 431                                 goto retry_create;
 432                         ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path);
 433                         return WIMLIB_ERR_OPEN;
 434                 }
 435                 /* On empty files, we can set timestamps immediately because we
 436                  * don't need to write any data to them.  */
 437                 ret = unix_set_metadata(fd, inode, path, ctx);
 438                 if (close(fd) && !ret) {
 439                         ERROR_WITH_ERRNO("Error closing \"%s\"", path);
 440                         ret = WIMLIB_ERR_WRITE;
 441                 }
 442         }
 443         if (ret)
 444                 return ret;
 445
 446         ret = unix_create_hardlinks(inode, dentry, path, ctx);
 447         if (ret)
 448                 return ret;
 449
 450         return report_file_created(&ctx->common);
 451 }
 452
 453 static int
 454 unix_create_dirs_and_empty_files(const struct list_head *dentry_list,
 455                                  struct unix_apply_ctx *ctx)
 456 {
 457         const struct wim_dentry *dentry;
 458         int ret;
 459
 460         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 461                 ret = unix_create_if_directory(dentry, ctx);
 462                 if (ret)
 463                         return ret;
 464         }
 465         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 466                 ret = unix_extract_if_empty_file(dentry, ctx);
 467                 if (ret)
 468                         return ret;
 469         }
 470         return 0;
 471 }
 472
 473 static void
 474 unix_count_dentries(const struct list_head *dentry_list,
 475                     uint64_t *dir_count_ret, uint64_t *empty_file_count_ret)
 476 {
 477         const struct wim_dentry *dentry;
 478         uint64_t dir_count = 0;
 479         uint64_t empty_file_count = 0;
 480
 481         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 482
 483                 const struct wim_inode *inode = dentry->d_inode;
 484
 485                 if (inode_is_directory(inode))
 486                         dir_count++;
 487                 else if ((dentry == inode_first_extraction_dentry(inode)) &&
 488                          !inode_unnamed_lte_resolved(inode))
 489                         empty_file_count++;
 490         }
 491
 492         *dir_count_ret = dir_count;
 493         *empty_file_count_ret = empty_file_count;
 494 }
 495
 496 static int
 497 unix_create_symlink(const struct wim_inode *inode, const char *path,
 498                     const u8 *rpdata, u16 rpdatalen, bool rpfix,
 499                     const char *apply_dir, size_t apply_dir_nchars)
 500 {
 501         char link_target[REPARSE_DATA_MAX_SIZE];
 502         int ret;
 503         struct wim_lookup_table_entry lte_override;
 504
 505         lte_override.resource_location = RESOURCE_IN_ATTACHED_BUFFER;
 506         lte_override.attached_buffer = (void *)rpdata;
 507         lte_override.size = rpdatalen;
 508
 509         ret = wim_inode_readlink(inode, link_target,
 510                                  sizeof(link_target) - 1, &lte_override);
 511         if (ret < 0) {
 512                 errno = -ret;
 513                 return WIMLIB_ERR_READLINK;
 514         }
 515
 516         link_target[ret] = 0;
 517
 518         if (rpfix && link_target[0] == '/') {
 519
 520                 /* "Fix" the absolute symbolic link by prepending the absolute
 521                  * path to the target directory.  */
 522
 523                 if (sizeof(link_target) - (ret + 1) < apply_dir_nchars) {
 524                         errno = ENAMETOOLONG;
 525                         return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED;
 526                 }
 527                 memmove(link_target + apply_dir_nchars, link_target,
 528                         ret + 1);
 529                 memcpy(link_target, apply_dir, apply_dir_nchars);
 530         }
 531 retry_symlink:
 532         if (symlink(link_target, path)) {
 533                 if (errno == EEXIST && !unlink(path))
 534                         goto retry_symlink;
 535                 return WIMLIB_ERR_LINK;
 536         }
 537         return 0;
 538 }
 539
 540 static void
 541 unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset)
 542 {
 543         for (unsigned i = offset; i < ctx->num_open_fds; i++)
 544                 filedes_close(&ctx->open_fds[i]);
 545         ctx->num_open_fds = 0;
 546 }
 547
 548 static int
 549 unix_begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
 550                                    const struct wim_inode *inode,
 551                                    struct unix_apply_ctx *ctx)
 552 {
 553         const struct wim_dentry *first_dentry;
 554         const char *first_path;
 555         int fd;
 556
 557         if (inode_is_symlink(inode)) {
 558                 /* On UNIX, symbolic links must be created with symlink(), which
 559                  * requires that the full link target be available.  */
 560                 if (stream->size > REPARSE_DATA_MAX_SIZE) {
 561                         ERROR_WITH_ERRNO("Reparse data of \"%s\" has size "
 562                                          "%"PRIu64" bytes (exceeds %u bytes)",
 563                                          inode_first_full_path(inode),
 564                                          stream->size, REPARSE_DATA_MAX_SIZE);
 565                         return WIMLIB_ERR_INVALID_REPARSE_DATA;
 566                 }
 567                 ctx->reparse_ptr = ctx->reparse_data;
 568                 return 0;
 569         }
 570
 571         /* This should be ensured by extract_stream_list()  */
 572         wimlib_assert(ctx->num_open_fds < MAX_OPEN_STREAMS);
 573
 574         first_dentry = inode_first_extraction_dentry(inode);
 575         first_path = unix_build_extraction_path(first_dentry, ctx);
 576 retry_create:
 577         fd = open(first_path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
 578         if (fd < 0) {
 579                 if (errno == EEXIST && !unlink(first_path))
 580                         goto retry_create;
 581                 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", first_path);
 582                 return WIMLIB_ERR_OPEN;
 583         }
 584         filedes_init(&ctx->open_fds[ctx->num_open_fds++], fd);
 585         return unix_create_hardlinks(inode, first_dentry, first_path, ctx);
 586 }
 587
 588 /* Called when starting to read a single-instance stream for extraction  */
 589 static int
 590 unix_begin_extract_stream(struct wim_lookup_table_entry *stream, void *_ctx)
 591 {
 592         struct unix_apply_ctx *ctx = _ctx;
 593         const struct stream_owner *owners = stream_owners(stream);
 594         int ret;
 595
 596         for (u32 i = 0; i < stream->out_refcnt; i++) {
 597                 const struct wim_inode *inode = owners[i].inode;
 598
 599                 ret = unix_begin_extract_stream_instance(stream, inode, ctx);
 600                 if (ret) {
 601                         ctx->reparse_ptr = NULL;
 602                         unix_cleanup_open_fds(ctx, 0);
 603                         return ret;
 604                 }
 605         }
 606         return 0;
 607 }
 608
 609 /* Called when the next chunk of a single-instance stream has been read for
 610  * extraction  */
 611 static int
 612 unix_extract_chunk(const void *chunk, size_t size, void *_ctx)
 613 {
 614         struct unix_apply_ctx *ctx = _ctx;
 615         int ret;
 616
 617         for (unsigned i = 0; i < ctx->num_open_fds; i++) {
 618                 ret = full_write(&ctx->open_fds[i], chunk, size);
 619                 if (ret) {
 620                         ERROR_WITH_ERRNO("Error writing data to filesystem");
 621                         return ret;
 622                 }
 623         }
 624         if (ctx->reparse_ptr)
 625                 ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size);
 626         return 0;
 627 }
 628
 629 /* Called when a single-instance stream has been fully read for extraction  */
 630 static int
 631 unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status,
 632                         void *_ctx)
 633 {
 634         struct unix_apply_ctx *ctx = _ctx;
 635         int ret;
 636         unsigned j;
 637         const struct stream_owner *owners = stream_owners(stream);
 638
 639         ctx->reparse_ptr = NULL;
 640
 641         if (status) {
 642                 unix_cleanup_open_fds(ctx, 0);
 643                 return status;
 644         }
 645
 646         j = 0;
 647         ret = 0;
 648         for (u32 i = 0; i < stream->out_refcnt; i++) {
 649                 struct wim_inode *inode = owners[i].inode;
 650
 651                 if (inode_is_symlink(inode)) {
 652                         /* We finally have the symlink data, so we can create
 653                          * the symlink.  */
 654                         const char *path;
 655                         bool rpfix;
 656
 657                         rpfix = (ctx->common.extract_flags &
 658                                  WIMLIB_EXTRACT_FLAG_RPFIX) &&
 659                                         !inode->i_not_rpfixed;
 660
 661                         path = unix_build_inode_extraction_path(inode, ctx);
 662                         ret = unix_create_symlink(inode, path,
 663                                                   ctx->reparse_data,
 664                                                   stream->size,
 665                                                   rpfix,
 666                                                   ctx->target_abspath,
 667                                                   ctx->target_abspath_nchars);
 668                         if (ret) {
 669                                 ERROR_WITH_ERRNO("Can't create symbolic link "
 670                                                  "\"%s\"", path);
 671                                 break;
 672                         }
 673                         ret = unix_set_metadata(-1, inode, path, ctx);
 674                         if (ret)
 675                                 break;
 676                 } else {
 677                         /* Set metadata on regular file just before closing it.
 678                          */
 679                         struct filedes *fd = &ctx->open_fds[j];
 680
 681                         ret = unix_set_metadata(fd->fd, inode, NULL, ctx);
 682                         if (ret)
 683                                 break;
 684
 685                         if (filedes_close(fd)) {
 686                                 ERROR_WITH_ERRNO("Error closing \"%s\"",
 687                                                  unix_build_inode_extraction_path(inode, ctx));
 688                                 ret = WIMLIB_ERR_WRITE;
 689                                 break;
 690                         }
 691                         j++;
 692                 }
 693         }
 694         unix_cleanup_open_fds(ctx, j);
 695         return ret;
 696 }
 697
 698 static int
 699 unix_set_dir_metadata(struct list_head *dentry_list, struct unix_apply_ctx *ctx)
 700 {
 701         const struct wim_dentry *dentry;
 702         int ret;
 703
 704         list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node) {
 705                 if (dentry_is_directory(dentry)) {
 706                         ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx);
 707                         if (ret)
 708                                 return ret;
 709                         ret = report_file_metadata_applied(&ctx->common);
 710                         if (ret)
 711                                 return ret;
 712                 }
 713         }
 714         return 0;
 715 }
 716
 717 static int
 718 unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
 719 {
 720         int ret;
 721         struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx;
 722         size_t path_max;
 723         uint64_t dir_count;
 724         uint64_t empty_file_count;
 725
 726         /* Compute the maximum path length that will be needed, then allocate
 727          * some path buffers.  */
 728         path_max = unix_compute_path_max(dentry_list, ctx);
 729
 730         for (unsigned i = 0; i < NUM_PATHBUFS; i++) {
 731                 ctx->pathbufs[i] = MALLOC(path_max);
 732                 if (!ctx->pathbufs[i]) {
 733                         ret = WIMLIB_ERR_NOMEM;
 734                         goto out;
 735                 }
 736                 /* Pre-fill the target in each path buffer.  We'll just append
 737                  * the rest of the paths after this.  */
 738                 memcpy(ctx->pathbufs[i],
 739                        ctx->common.target, ctx->common.target_nchars);
 740         }
 741
 742         /* Extract directories and empty regular files.  Directories are needed
 743          * because we can't extract any other files until their directories
 744          * exist.  Empty files are needed because they don't have
 745          * representatives in the stream list.  */
 746
 747         unix_count_dentries(dentry_list, &dir_count, &empty_file_count);
 748
 749         ret = start_file_structure_phase(&ctx->common, dir_count + empty_file_count);
 750         if (ret)
 751                 goto out;
 752
 753         ret = unix_create_dirs_and_empty_files(dentry_list, ctx);
 754         if (ret)
 755                 goto out;
 756
 757         ret = end_file_structure_phase(&ctx->common);
 758         if (ret)
 759                 goto out;
 760
 761         /* Get full path to target if needed for absolute symlink fixups.  */
 762         if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) &&
 763             ctx->common.required_features.symlink_reparse_points)
 764         {
 765                 ctx->target_abspath = realpath(ctx->common.target, NULL);
 766                 if (!ctx->target_abspath) {
 767                         ret = WIMLIB_ERR_NOMEM;
 768                         goto out;
 769                 }
 770                 ctx->target_abspath_nchars = strlen(ctx->target_abspath);
 771         }
 772
 773         /* Extract nonempty regular files and symbolic links.  */
 774
 775         struct read_stream_list_callbacks cbs = {
 776                 .begin_stream      = unix_begin_extract_stream,
 777                 .begin_stream_ctx  = ctx,
 778                 .consume_chunk     = unix_extract_chunk,
 779                 .consume_chunk_ctx = ctx,
 780                 .end_stream        = unix_end_extract_stream,
 781                 .end_stream_ctx    = ctx,
 782         };
 783         ret = extract_stream_list(&ctx->common, &cbs);
 784         if (ret)
 785                 goto out;
 786
 787
 788         /* Set directory metadata.  We do this last so that we get the right
 789          * directory timestamps.  */
 790         ret = start_file_metadata_phase(&ctx->common, dir_count);
 791         if (ret)
 792                 goto out;
 793
 794         ret = unix_set_dir_metadata(dentry_list, ctx);
 795         if (ret)
 796                 goto out;
 797
 798         ret = end_file_metadata_phase(&ctx->common);
 799         if (ret)
 800                 goto out;
 801
 802         if (ctx->num_special_files_ignored) {
 803                 WARNING("%lu special files were not extracted due to EPERM!",
 804                         ctx->num_special_files_ignored);
 805         }
 806 out:
 807         for (unsigned i = 0; i < NUM_PATHBUFS; i++)
 808                 FREE(ctx->pathbufs[i]);
 809         FREE(ctx->target_abspath);
 810         return ret;
 811 }
 812
 813 const struct apply_operations unix_apply_ops = {
 814         .name                   = "UNIX",
 815         .get_supported_features = unix_get_supported_features,
 816         .extract                = unix_extract,
 817         .context_size           = sizeof(struct unix_apply_ctx),
 818 };