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