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