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