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 part of wimlib, a library for working with WIM files.
   9  *
  10  * wimlib is free software; you can redistribute it and/or modify it under the
  11  * terms of the GNU General Public License as published by the Free
  12  * Software Foundation; either version 3 of the License, or (at your option)
  13  * any later version.
  14  *
  15  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
  16  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  17  * A PARTICULAR PURPOSE. See the GNU General Public License for more
  18  * details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include "config.h"
  26 #endif
  27
  28 #include "wimlib/apply.h"
  29 #include "wimlib/dentry.h"
  30 #include "wimlib/error.h"
  31 #include "wimlib/file_io.h"
  32 #include "wimlib/reparse.h"
  33 #include "wimlib/timestamp.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 #define MAX_OPEN_FDS 1024 /* TODO: Add special case for when the number of
  67                              identical streams exceeds this number.  */
  68
  69 struct unix_apply_ctx {
  70         /* Extract flags, the pointer to the WIMStruct, etc.  */
  71         struct apply_ctx common;
  72
  73         /* Buffers for building extraction paths (allocated).  */
  74         char *pathbufs[NUM_PATHBUFS];
  75
  76         /* Index of next pathbuf to use  */
  77         unsigned which_pathbuf;
  78
  79         /* Currently open file descriptors for extraction  */
  80         struct filedes open_fds[MAX_OPEN_FDS];
  81
  82         /* Number of currently open file descriptors in open_fds, starting from
  83          * the beginning of the array.  */
  84         unsigned num_open_fds;
  85
  86         /* Buffer for reading reparse data streams into memory  */
  87         u8 reparse_data[REPARSE_DATA_MAX_SIZE];
  88
  89         /* Pointer to the next byte in @reparse_data to fill  */
  90         u8 *reparse_ptr;
  91
  92         /* Absolute path to the target directory (allocated buffer).  Only set
  93          * if needed for absolute symbolic link fixups.  */
  94         char *target_abspath;
  95
  96         /* Number of characters in target_abspath.  */
  97         size_t target_abspath_nchars;
  98 };
  99
 100 /* Returns the number of characters needed to represent the path to the
 101  * specified @dentry when extracted, not including the null terminator or the
 102  * path to the target directory itself.  */
 103 static size_t
 104 unix_dentry_path_length(const struct wim_dentry *dentry)
 105 {
 106         size_t len = 0;
 107         const struct wim_dentry *d;
 108
 109         d = dentry;
 110         do {
 111                 len += d->d_extraction_name_nchars + 1;
 112                 d = d->parent;
 113         } while (!dentry_is_root(d) && will_extract_dentry(d));
 114
 115         return len;
 116 }
 117
 118 /* Returns the maximum number of characters needed to represent the path to any
 119  * dentry in @dentry_list when extracted, including the null terminator and the
 120  * path to the target directory itself.  */
 121 static size_t
 122 unix_compute_path_max(const struct list_head *dentry_list,
 123                       const struct unix_apply_ctx *ctx)
 124 {
 125         size_t max = 0;
 126         size_t len;
 127         const struct wim_dentry *dentry;
 128
 129         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 130                 len = unix_dentry_path_length(dentry);
 131                 if (len > max)
 132                         max = len;
 133         }
 134
 135         /* Account for target and null terminator.  */
 136         return ctx->common.target_nchars + max + 1;
 137 }
 138
 139 /* Builds and returns the filesystem path to which to extract @dentry.
 140  * This cycles through NUM_PATHBUFS different buffers.  */
 141 static const char *
 142 unix_build_extraction_path(const struct wim_dentry *dentry,
 143                            struct unix_apply_ctx *ctx)
 144 {
 145         char *pathbuf;
 146         char *p;
 147         const struct wim_dentry *d;
 148
 149         pathbuf = ctx->pathbufs[ctx->which_pathbuf];
 150         ctx->which_pathbuf = (ctx->which_pathbuf + 1) % NUM_PATHBUFS;
 151
 152         p = &pathbuf[ctx->common.target_nchars +
 153                      unix_dentry_path_length(dentry)];
 154         *p = '\0';
 155         d = dentry;
 156         do {
 157                 p -= d->d_extraction_name_nchars;
 158                 memcpy(p, d->d_extraction_name, d->d_extraction_name_nchars);
 159                 *--p = '/';
 160                 d = d->parent;
 161         } while (!dentry_is_root(d) && will_extract_dentry(d));
 162
 163         return pathbuf;
 164 }
 165
 166 /* This causes the next call to unix_build_extraction_path() to use the same
 167  * path buffer as the previous call.  */
 168 static void
 169 unix_reuse_pathbuf(struct unix_apply_ctx *ctx)
 170 {
 171         ctx->which_pathbuf = (ctx->which_pathbuf - 1) % NUM_PATHBUFS;
 172 }
 173
 174 /* Builds and returns the filesystem path to which to extract an unspecified
 175  * alias of the @inode.  This cycles through NUM_PATHBUFS different buffers.  */
 176 static const char *
 177 unix_build_inode_extraction_path(const struct wim_inode *inode,
 178                                  struct unix_apply_ctx *ctx)
 179 {
 180         return unix_build_extraction_path(inode_first_extraction_dentry(inode), ctx);
 181 }
 182
 183 /* Sets the timestamps on a file being extracted.
 184  *
 185  * Either @fd or @path must be specified (not -1 and not NULL, respectively).
 186  */
 187 static int
 188 unix_set_timestamps(int fd, const char *path, u64 atime, u64 mtime)
 189 {
 190         {
 191                 struct timespec times[2];
 192
 193                 times[0] = wim_timestamp_to_timespec(atime);
 194                 times[1] = wim_timestamp_to_timespec(mtime);
 195
 196                 errno = ENOSYS;
 197 #ifdef HAVE_FUTIMENS
 198                 if (fd >= 0 && !futimens(fd, times))
 199                         return 0;
 200 #endif
 201 #ifdef HAVE_UTIMENSAT
 202                 if (fd < 0 && !utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW))
 203                         return 0;
 204 #endif
 205                 if (errno != ENOSYS)
 206                         return WIMLIB_ERR_SET_TIMESTAMPS;
 207         }
 208         {
 209                 struct timeval times[2];
 210
 211                 times[0] = wim_timestamp_to_timeval(atime);
 212                 times[1] = wim_timestamp_to_timeval(mtime);
 213
 214                 if (fd >= 0 && !futimes(fd, times))
 215                         return 0;
 216                 if (fd < 0 && !lutimes(path, times))
 217                         return 0;
 218                 return WIMLIB_ERR_SET_TIMESTAMPS;
 219         }
 220 }
 221
 222 /*
 223  * Set metadata on an extracted file.
 224  *
 225  * @fd is an open file descriptor to the extracted file, or -1.  @path is the
 226  * path to the extracted file, or NULL.  If valid, this function uses @fd.
 227  * Otherwise, if valid, it uses @path.  Otherwise, it calculates the path to one
 228  * alias of the extracted file and uses it.
 229  */
 230 static int
 231 unix_set_metadata(int fd, const struct wim_inode *inode,
 232                   const char *path, struct unix_apply_ctx *ctx)
 233 {
 234         int ret;
 235
 236         if (fd < 0 && !path)
 237                 path = unix_build_inode_extraction_path(inode, ctx);
 238
 239         ret = unix_set_timestamps(fd, path,
 240                                   inode->i_last_access_time,
 241                                   inode->i_last_write_time);
 242         if (ret) {
 243                 if (!path)
 244                         path = unix_build_inode_extraction_path(inode, ctx);
 245                 if (ctx->common.extract_flags &
 246                     WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS)
 247                 {
 248                         ERROR_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
 249                         return ret;
 250                 } else {
 251                         WARNING_WITH_ERRNO("Can't set timestamps on \"%s\"", path);
 252                 }
 253         }
 254         return 0;
 255 }
 256
 257 /* Extract all needed aliases of the @inode, where one alias, corresponding to
 258  * @first_dentry, has already been extracted to @first_path.  */
 259 static int
 260 unix_create_hardlinks(const struct wim_inode *inode,
 261                       const struct wim_dentry *first_dentry,
 262                       const char *first_path, struct unix_apply_ctx *ctx)
 263 {
 264         const struct wim_dentry *dentry;
 265         const char *newpath;
 266
 267         list_for_each_entry(dentry, &inode->i_extraction_aliases,
 268                             d_extraction_alias_node)
 269         {
 270                 if (dentry == first_dentry)
 271                         continue;
 272
 273                 newpath = unix_build_extraction_path(dentry, ctx);
 274         retry_link:
 275                 if (link(first_path, newpath)) {
 276                         if (errno == EEXIST && !unlink(newpath))
 277                                 goto retry_link;
 278                         ERROR_WITH_ERRNO("Can't create hard link "
 279                                          "\"%s\" => \"%s\"", newpath, first_path);
 280                         return WIMLIB_ERR_LINK;
 281                 }
 282                 unix_reuse_pathbuf(ctx);
 283         }
 284         return 0;
 285 }
 286
 287 /* If @dentry represents a directory, create it.  */
 288 static int
 289 unix_create_if_directory(const struct wim_dentry *dentry,
 290                          struct unix_apply_ctx *ctx)
 291 {
 292         const char *path;
 293         struct stat stbuf;
 294
 295         if (!dentry_is_directory(dentry))
 296                 return 0;
 297
 298         path = unix_build_extraction_path(dentry, ctx);
 299         if (mkdir(path, 0755) &&
 300             /* It's okay if the path already exists, as long as it's a
 301              * directory.  */
 302             !(errno == EEXIST && !lstat(path, &stbuf) && S_ISDIR(stbuf.st_mode)))
 303         {
 304                 ERROR_WITH_ERRNO("Can't create directory \"%s\"", path);
 305                 return WIMLIB_ERR_MKDIR;
 306         }
 307         return 0;
 308 }
 309
 310 /* If @dentry represents an empty regular file, create it, set its metadata, and
 311  * create any needed hard links.  */
 312 static int
 313 unix_extract_if_empty_file(const struct wim_dentry *dentry,
 314                            struct unix_apply_ctx *ctx)
 315 {
 316         const struct wim_inode *inode;
 317         const char *path;
 318         int fd;
 319         int ret;
 320
 321         inode = dentry->d_inode;
 322
 323         /* Extract all aliases only when the "first" comes up.  */
 324         if (dentry != inode_first_extraction_dentry(inode))
 325                 return 0;
 326
 327         /* Not an empty regular file?  */
 328         if (inode_is_directory(inode) || inode_is_symlink(inode) ||
 329             inode_unnamed_lte_resolved(inode))
 330                 return 0;
 331
 332         path = unix_build_extraction_path(dentry, ctx);
 333 retry_create:
 334         fd = open(path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
 335         if (fd < 0) {
 336                 if (errno == EEXIST && !unlink(path))
 337                         goto retry_create;
 338                 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", path);
 339                 return WIMLIB_ERR_OPEN;
 340         }
 341         /* On empty files, we can set timestamps immediately because we don't
 342          * need to write any data to them.  */
 343         ret = unix_set_metadata(fd, inode, path, ctx);
 344         if (close(fd) && !ret) {
 345                 ERROR_WITH_ERRNO("Error closing \"%s\"", path);
 346                 ret = WIMLIB_ERR_WRITE;
 347         }
 348         if (ret)
 349                 return ret;
 350
 351         return unix_create_hardlinks(inode, dentry, path, ctx);
 352 }
 353
 354 static int
 355 unix_create_dirs_and_empty_files(const struct list_head *dentry_list,
 356                                  struct unix_apply_ctx *ctx)
 357 {
 358         const struct wim_dentry *dentry;
 359         int ret;
 360
 361         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 362                 ret = unix_create_if_directory(dentry, ctx);
 363                 if (ret)
 364                         return ret;
 365         }
 366         list_for_each_entry(dentry, dentry_list, d_extraction_list_node) {
 367                 ret = unix_extract_if_empty_file(dentry, ctx);
 368                 if (ret)
 369                         return ret;
 370         }
 371         return 0;
 372 }
 373
 374 static int
 375 unix_create_symlink(const struct wim_inode *inode, const char *path,
 376                     const u8 *rpdata, u16 rpdatalen, bool rpfix,
 377                     const char *apply_dir, size_t apply_dir_nchars)
 378 {
 379         char link_target[REPARSE_DATA_MAX_SIZE];
 380         int ret;
 381         struct wim_lookup_table_entry lte_override;
 382
 383         lte_override.resource_location = RESOURCE_IN_ATTACHED_BUFFER;
 384         lte_override.attached_buffer = (void *)rpdata;
 385         lte_override.size = rpdatalen;
 386
 387         ret = wim_inode_readlink(inode, link_target,
 388                                  sizeof(link_target) - 1, &lte_override);
 389         if (ret < 0) {
 390                 errno = -ret;
 391                 return WIMLIB_ERR_READLINK;
 392         }
 393
 394         link_target[ret] = 0;
 395
 396         if (rpfix && link_target[0] == '/') {
 397
 398                 /* "Fix" the absolute symbolic link by prepending the absolute
 399                  * path to the target directory.  */
 400
 401                 if (sizeof(link_target) - (ret + 1) < apply_dir_nchars) {
 402                         errno = ENAMETOOLONG;
 403                         return WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED;
 404                 }
 405                 memmove(link_target + apply_dir_nchars, link_target,
 406                         ret + 1);
 407                 memcpy(link_target, apply_dir, apply_dir_nchars);
 408         }
 409 retry_symlink:
 410         if (symlink(link_target, path)) {
 411                 if (errno == EEXIST && !unlink(path))
 412                         goto retry_symlink;
 413                 return WIMLIB_ERR_LINK;
 414         }
 415         return 0;
 416 }
 417
 418 static void
 419 unix_cleanup_open_fds(struct unix_apply_ctx *ctx, unsigned offset)
 420 {
 421         for (unsigned i = offset; i < ctx->num_open_fds; i++)
 422                 filedes_close(&ctx->open_fds[i]);
 423         ctx->num_open_fds = 0;
 424 }
 425
 426 static int
 427 unix_begin_extract_stream_instance(const struct wim_lookup_table_entry *stream,
 428                                    const struct wim_inode *inode,
 429                                    struct unix_apply_ctx *ctx)
 430 {
 431         const struct wim_dentry *first_dentry;
 432         const char *first_path;
 433         int fd;
 434
 435         if (inode_is_symlink(inode)) {
 436                 /* On UNIX, symbolic links must be created with symlink(), which
 437                  * requires that the full link target be available.  */
 438                 if (stream->size > REPARSE_DATA_MAX_SIZE) {
 439                         ERROR_WITH_ERRNO("Reparse data of \"%s\" has size "
 440                                          "%"PRIu64" bytes (exceeds %u bytes)",
 441                                          inode_first_full_path(inode),
 442                                          stream->size, REPARSE_DATA_MAX_SIZE);
 443                         return WIMLIB_ERR_INVALID_REPARSE_DATA;
 444                 }
 445                 ctx->reparse_ptr = ctx->reparse_data;
 446                 return 0;
 447         }
 448
 449         first_dentry = inode_first_extraction_dentry(inode);
 450         first_path = unix_build_extraction_path(first_dentry, ctx);
 451 retry_create:
 452         fd = open(first_path, O_TRUNC | O_CREAT | O_WRONLY | O_NOFOLLOW, 0644);
 453         if (fd < 0) {
 454                 if (errno == EEXIST && !unlink(first_path))
 455                         goto retry_create;
 456                 ERROR_WITH_ERRNO("Can't create regular file \"%s\"", first_path);
 457                 return WIMLIB_ERR_OPEN;
 458         }
 459         filedes_init(&ctx->open_fds[ctx->num_open_fds++], fd);
 460         return unix_create_hardlinks(inode, first_dentry, first_path, ctx);
 461 }
 462
 463 /* Called when starting to read a single-instance stream for extraction  */
 464 static int
 465 unix_begin_extract_stream(struct wim_lookup_table_entry *stream,
 466                           u32 flags, void *_ctx)
 467 {
 468         struct unix_apply_ctx *ctx = _ctx;
 469         const struct stream_owner *owners = stream_owners(stream);
 470         int ret;
 471
 472         for (u32 i = 0; i < stream->out_refcnt; i++) {
 473                 const struct wim_inode *inode = owners[i].inode;
 474
 475                 ret = unix_begin_extract_stream_instance(stream, inode, ctx);
 476                 if (ret) {
 477                         ctx->reparse_ptr = NULL;
 478                         unix_cleanup_open_fds(ctx, 0);
 479                         return ret;
 480                 }
 481         }
 482         return 0;
 483 }
 484
 485 /* Called when the next chunk of a single-instance stream has been read for
 486  * extraction  */
 487 static int
 488 unix_extract_chunk(const void *chunk, size_t size, void *_ctx)
 489 {
 490         struct unix_apply_ctx *ctx = _ctx;
 491         int ret;
 492
 493         for (unsigned i = 0; i < ctx->num_open_fds; i++) {
 494                 ret = full_write(&ctx->open_fds[i], chunk, size);
 495                 if (ret) {
 496                         ERROR_WITH_ERRNO("Error writing data to filesystem");
 497                         return ret;
 498                 }
 499         }
 500         if (ctx->reparse_ptr)
 501                 ctx->reparse_ptr = mempcpy(ctx->reparse_ptr, chunk, size);
 502         return 0;
 503 }
 504
 505 /* Called when a single-instance stream has been fully read for extraction  */
 506 static int
 507 unix_end_extract_stream(struct wim_lookup_table_entry *stream, int status,
 508                         void *_ctx)
 509 {
 510         struct unix_apply_ctx *ctx = _ctx;
 511         int ret;
 512         unsigned j;
 513         const struct stream_owner *owners = stream_owners(stream);
 514
 515         ctx->reparse_ptr = NULL;
 516
 517         if (status) {
 518                 unix_cleanup_open_fds(ctx, 0);
 519                 return status;
 520         }
 521
 522         j = 0;
 523         ret = 0;
 524         for (u32 i = 0; i < stream->out_refcnt; i++) {
 525                 struct wim_inode *inode = owners[i].inode;
 526
 527                 if (inode_is_symlink(inode)) {
 528                         /* We finally have the symlink data, so we can create
 529                          * the symlink.  */
 530                         const char *path;
 531
 532                         path = unix_build_inode_extraction_path(inode, ctx);
 533                         ret = unix_create_symlink(inode, path,
 534                                                   ctx->reparse_data,
 535                                                   stream->size,
 536                                                   (ctx->common.extract_flags &
 537                                                    WIMLIB_EXTRACT_FLAG_RPFIX),
 538                                                   ctx->target_abspath,
 539                                                   ctx->target_abspath_nchars);
 540                         if (ret) {
 541                                 ERROR_WITH_ERRNO("Can't create symbolic link "
 542                                                  "\"%s\"", path);
 543                                 break;
 544                         }
 545                         ret = unix_set_metadata(-1, inode, path, ctx);
 546                         if (ret)
 547                                 break;
 548                 } else {
 549                         /* Set metadata on regular file just before closing it.
 550                          */
 551                         struct filedes *fd = &ctx->open_fds[j];
 552
 553                         ret = unix_set_metadata(fd->fd, inode, NULL, ctx);
 554                         if (ret)
 555                                 break;
 556
 557                         if (filedes_close(fd)) {
 558                                 ERROR_WITH_ERRNO("Error closing \"%s\"",
 559                                                  unix_build_inode_extraction_path(inode, ctx));
 560                                 ret = WIMLIB_ERR_WRITE;
 561                                 break;
 562                         }
 563                         j++;
 564                 }
 565         }
 566         unix_cleanup_open_fds(ctx, j);
 567         return ret;
 568 }
 569
 570 static int
 571 unix_set_dir_metadata(struct list_head *dentry_list, struct unix_apply_ctx *ctx)
 572 {
 573         const struct wim_dentry *dentry;
 574         int ret;
 575
 576         list_for_each_entry_reverse(dentry, dentry_list, d_extraction_list_node) {
 577                 if (dentry_is_directory(dentry)) {
 578                         ret = unix_set_metadata(-1, dentry->d_inode, NULL, ctx);
 579                         if (ret)
 580                                 return ret;
 581                 }
 582         }
 583         return 0;
 584 }
 585
 586 static int
 587 unix_extract(struct list_head *dentry_list, struct apply_ctx *_ctx)
 588 {
 589         int ret;
 590         struct unix_apply_ctx *ctx = (struct unix_apply_ctx *)_ctx;
 591         size_t path_max;
 592
 593         /* Compute the maximum path length that will be needed, then allocate
 594          * some path buffers.  */
 595         path_max = unix_compute_path_max(dentry_list, ctx);
 596
 597         for (unsigned i = 0; i < NUM_PATHBUFS; i++) {
 598                 ctx->pathbufs[i] = MALLOC(path_max);
 599                 if (!ctx->pathbufs[i]) {
 600                         ret = WIMLIB_ERR_NOMEM;
 601                         goto out;
 602                 }
 603                 /* Pre-fill the target in each path buffer.  We'll just append
 604                  * the rest of the paths after this.  */
 605                 memcpy(ctx->pathbufs[i],
 606                        ctx->common.target, ctx->common.target_nchars);
 607         }
 608
 609         /* Extract directories and empty regular files.  Directories are needed
 610          * because we can't extract any other files until their directories
 611          * exist.  Empty files are needed because they don't have
 612          * representatives in the stream list.  */
 613         ret = unix_create_dirs_and_empty_files(dentry_list, ctx);
 614         if (ret)
 615                 goto out;
 616
 617         /* Get full path to target if needed for absolute symlink fixups.  */
 618         if ((ctx->common.extract_flags & WIMLIB_EXTRACT_FLAG_RPFIX) &&
 619             ctx->common.required_features.symlink_reparse_points)
 620         {
 621                 ctx->target_abspath = realpath(ctx->common.target, NULL);
 622                 if (!ctx->target_abspath) {
 623                         ret = WIMLIB_ERR_NOMEM;
 624                         goto out;
 625                 }
 626                 ctx->target_abspath_nchars = strlen(ctx->target_abspath);
 627         }
 628
 629         /* Extract nonempty regular files and symbolic links.  */
 630
 631         struct read_stream_list_callbacks cbs = {
 632                 .begin_stream      = unix_begin_extract_stream,
 633                 .begin_stream_ctx  = ctx,
 634                 .consume_chunk     = unix_extract_chunk,
 635                 .consume_chunk_ctx = ctx,
 636                 .end_stream        = unix_end_extract_stream,
 637                 .end_stream_ctx    = ctx,
 638         };
 639         ret = extract_stream_list(&ctx->common, &cbs);
 640         if (ret)
 641                 goto out;
 642
 643         /* Set directory metadata.  We do this last so that we get the right
 644          * directory timestamps.  */
 645         ret = unix_set_dir_metadata(dentry_list, ctx);
 646 out:
 647         for (unsigned i = 0; i < NUM_PATHBUFS; i++)
 648                 FREE(ctx->pathbufs[i]);
 649         FREE(ctx->target_abspath);
 650         return ret;
 651 }
 652
 653 const struct apply_operations unix_apply_ops = {
 654         .name                   = "UNIX",
 655         .get_supported_features = unix_get_supported_features,
 656         .extract                = unix_extract,
 657         .context_size           = sizeof(struct unix_apply_ctx),
 658 };