1 /* Extract files from a tar archive.
3 Copyright 1988, 1992-1994, 1996-2001, 2003-2007, 2010, 2012-2014 Free
4 Software Foundation, Inc.
6 This file is part of GNU tar.
8 GNU tar is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 GNU tar is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 Written by John Gilmore, on 1985-11-19. */
32 static bool we_are_root; /* true if our effective uid == 0 */
33 static mode_t newdir_umask; /* umask when creating new directories */
34 static mode_t current_umask; /* current umask (which is set to 0 if -p) */
36 #define ALL_MODE_BITS ((mode_t) ~ (mode_t) 0)
38 #if ! HAVE_FCHMOD && ! defined fchmod
39 # define fchmod(fd, mode) (errno = ENOSYS, -1)
41 #if ! HAVE_FCHOWN && ! defined fchown
42 # define fchown(fd, uid, gid) (errno = ENOSYS, -1)
45 /* Return true if an error number ERR means the system call is
46 supported in this case. */
50 return ! (err == ENOSYS
52 || (EOPNOTSUPP != ENOTSUP && err == EOPNOTSUPP));
55 /* List of directories whose statuses we need to extract after we've
56 finished extracting their subsidiary files. If you consider each
57 contiguous subsequence of elements of the form [D]?[^D]*, where [D]
58 represents an element where AFTER_LINKS is nonzero and [^D]
59 represents an element where AFTER_LINKS is zero, then the head
60 of the subsequence has the longest name, and each non-head element
61 in the prefix is an ancestor (in the directory hierarchy) of the
64 struct delayed_set_stat
66 /* Next directory in list. */
67 struct delayed_set_stat *next;
69 /* Metadata for this directory. */
72 mode_t mode; /* The desired mode is MODE & ~ current_umask. */
75 struct timespec atime;
76 struct timespec mtime;
78 /* An estimate of the directory's current mode, along with a mask
79 specifying which bits of this estimate are known to be correct.
80 If CURRENT_MODE_MASK is zero, CURRENT_MODE's value doesn't
83 mode_t current_mode_mask;
85 /* This directory is an intermediate directory that was created
86 as an ancestor of some other directory; it was not mentioned
87 in the archive, so do not set its uid, gid, atime, or mtime,
88 and don't alter its mode outside of MODE_RWX. */
91 /* Whether symbolic links should be followed when accessing the
95 /* Do not set the status of this directory until after delayed
99 /* Directory that the name is relative to. */
102 /* extended attributes*/
108 size_t xattr_map_size;
109 struct xattr_array *xattr_map;
110 /* Length and contents of name. */
111 size_t file_name_len;
115 static struct delayed_set_stat *delayed_set_stat_head;
117 /* List of links whose creation we have delayed. */
120 /* The next delayed link in the list. */
121 struct delayed_link *next;
123 /* The device, inode number and birthtime of the placeholder.
124 birthtime.tv_nsec is negative if the birthtime is not available.
125 Don't use mtime as this would allow for false matches if some
126 other process removes the placeholder. Don't use ctime as
127 this would cause race conditions and other screwups, e.g.,
128 when restoring hard-linked symlinks. */
131 struct timespec birthtime;
133 /* True if the link is symbolic. */
136 /* The desired metadata, valid only the link is symbolic. */
140 struct timespec atime;
141 struct timespec mtime;
143 /* The directory that the sources and target are relative to. */
146 /* A list of sources for this link. The sources are all to be
147 hard-linked together. */
148 struct string_list *sources;
150 /* SELinux context */
159 size_t xattr_map_size;
160 struct xattr_array *xattr_map;
162 /* The desired target of the desired link. */
166 static struct delayed_link *delayed_link_head;
170 struct string_list *next;
174 /* Set up to extract files. */
178 we_are_root = geteuid () == ROOT_UID;
179 same_permissions_option += we_are_root;
180 same_owner_option += we_are_root;
182 /* Option -p clears the kernel umask, so it does not affect proper
183 restoration of file permissions. New intermediate directories will
184 comply with umask at start of program. */
186 newdir_umask = umask (0);
187 if (0 < same_permissions_option)
191 umask (newdir_umask); /* restore the kernel umask */
192 current_umask = newdir_umask;
196 /* Use fchmod if possible, fchmodat otherwise. */
198 fd_chmod (int fd, char const *file, mode_t mode, int atflag)
202 int result = fchmod (fd, mode);
203 if (result == 0 || implemented (errno))
206 return fchmodat (chdir_fd, file, mode, atflag);
209 /* Use fchown if possible, fchownat otherwise. */
211 fd_chown (int fd, char const *file, uid_t uid, gid_t gid, int atflag)
215 int result = fchown (fd, uid, gid);
216 if (result == 0 || implemented (errno))
219 return fchownat (chdir_fd, file, uid, gid, atflag);
222 /* Use fstat if possible, fstatat otherwise. */
224 fd_stat (int fd, char const *file, struct stat *st, int atflag)
228 : fstatat (chdir_fd, file, st, atflag));
231 /* Set the mode for FILE_NAME to MODE.
232 MODE_MASK specifies the bits of MODE that we care about;
233 thus if MODE_MASK is zero, do nothing.
234 If FD is nonnegative, it is a file descriptor for the file.
235 CURRENT_MODE and CURRENT_MODE_MASK specify information known about
236 the file's current mode, using the style of struct delayed_set_stat.
237 TYPEFLAG specifies the type of the file.
238 ATFLAG specifies the flag to use when statting the file. */
240 set_mode (char const *file_name,
241 mode_t mode, mode_t mode_mask, int fd,
242 mode_t current_mode, mode_t current_mode_mask,
243 char typeflag, int atflag)
245 if (((current_mode ^ mode) | ~ current_mode_mask) & mode_mask)
247 if (MODE_ALL & ~ mode_mask & ~ current_mode_mask)
250 if (fd_stat (fd, file_name, &st, atflag) != 0)
252 stat_error (file_name);
255 current_mode = st.st_mode;
258 current_mode &= MODE_ALL;
259 mode = (current_mode & ~ mode_mask) | (mode & mode_mask);
261 if (current_mode != mode)
264 fd_chmod (fd, file_name, mode, atflag) == 0 ? 0 : errno;
266 /* On Solaris, chmod may fail if we don't have PRIV_ALL, because
267 setuid-root files would otherwise be a backdoor. See
268 http://opensolaris.org/jive/thread.jspa?threadID=95826
270 if (chmod_errno == EPERM && (mode & S_ISUID)
271 && priv_set_restore_linkdir () == 0)
274 fd_chmod (fd, file_name, mode, atflag) == 0 ? 0 : errno;
275 priv_set_remove_linkdir ();
278 /* Linux fchmodat does not support AT_SYMLINK_NOFOLLOW, and
279 returns ENOTSUP even when operating on non-symlinks, try
280 again with the flag disabled if it does not appear to be
281 supported and if the file is not a symlink. This
282 introduces a race, alas. */
283 if (atflag && typeflag != SYMTYPE && ! implemented (chmod_errno))
284 chmod_errno = fd_chmod (fd, file_name, mode, 0) == 0 ? 0 : errno;
287 && (typeflag != SYMTYPE || implemented (chmod_errno)))
290 chmod_error_details (file_name, mode);
296 /* Check time after successfully setting FILE_NAME's time stamp to T. */
298 check_time (char const *file_name, struct timespec t)
301 WARNOPT (WARN_TIMESTAMP,
302 (0, 0, _("%s: implausibly old time stamp %s"),
303 file_name, tartime (t, true)));
304 else if (timespec_cmp (volume_start_time, t) < 0)
308 if (timespec_cmp (now, t) < 0)
310 char buf[TIMESPEC_STRSIZE_BOUND];
311 struct timespec diff;
312 diff.tv_sec = t.tv_sec - now.tv_sec;
313 diff.tv_nsec = t.tv_nsec - now.tv_nsec;
314 if (diff.tv_nsec < 0)
316 diff.tv_nsec += BILLION;
319 WARNOPT (WARN_TIMESTAMP,
320 (0, 0, _("%s: time stamp %s is %s s in the future"),
321 file_name, tartime (t, true), code_timespec (diff, buf)));
326 /* Restore stat attributes (owner, group, mode and times) for
327 FILE_NAME, using information given in *ST.
328 If FD is nonnegative, it is a file descriptor for the file.
329 CURRENT_MODE and CURRENT_MODE_MASK specify information known about
330 the file's current mode, using the style of struct delayed_set_stat.
331 TYPEFLAG specifies the type of the file.
332 If INTERDIR, this is an intermediate directory.
333 ATFLAG specifies the flag to use when statting the file. */
336 set_stat (char const *file_name,
337 struct tar_stat_info const *st,
338 int fd, mode_t current_mode, mode_t current_mode_mask,
339 char typeflag, bool interdir, int atflag)
341 /* Do the utime before the chmod because some versions of utime are
342 broken and trash the modes of the file. */
344 if (! touch_option && ! interdir)
346 struct timespec ts[2];
347 if (incremental_option)
350 ts[0].tv_nsec = UTIME_OMIT;
353 if (fdutimensat (fd, chdir_fd, file_name, ts, atflag) == 0)
355 if (incremental_option)
356 check_time (file_name, ts[0]);
357 check_time (file_name, ts[1]);
359 else if (typeflag != SYMTYPE || implemented (errno))
360 utime_error (file_name);
363 if (0 < same_owner_option && ! interdir)
365 /* Some systems allow non-root users to give files away. Once this
366 done, it is not possible anymore to change file permissions.
367 However, setting file permissions now would be incorrect, since
368 they would apply to the wrong user, and there would be a race
369 condition. So, don't use systems that allow non-root users to
371 uid_t uid = st->stat.st_uid;
372 gid_t gid = st->stat.st_gid;
374 if (fd_chown (fd, file_name, uid, gid, atflag) == 0)
376 /* Changing the owner can clear st_mode bits in some cases. */
377 if ((current_mode | ~ current_mode_mask) & S_IXUGO)
378 current_mode_mask &= ~ (current_mode & (S_ISUID | S_ISGID));
380 else if (typeflag != SYMTYPE || implemented (errno))
381 chown_error_details (file_name, uid, gid);
385 st->stat.st_mode & ~ current_umask,
386 0 < same_permissions_option && ! interdir ? MODE_ALL : MODE_RWX,
387 fd, current_mode, current_mode_mask, typeflag, atflag);
389 /* these three calls must be done *after* fd_chown() call because fd_chown
390 causes that linux capabilities becomes cleared. */
391 xattrs_xattrs_set (st, file_name, typeflag, 1);
392 xattrs_acls_set (st, file_name, typeflag);
393 xattrs_selinux_set (st, file_name, typeflag);
396 /* For each entry H in the leading prefix of entries in HEAD that do
397 not have after_links marked, mark H and fill in its dev and ino
398 members. Assume HEAD && ! HEAD->after_links. */
400 mark_after_links (struct delayed_set_stat *head)
402 struct delayed_set_stat *h = head;
409 if (deref_stat (h->file_name, &st) != 0)
410 stat_error (h->file_name);
417 while ((h = h->next) && ! h->after_links);
420 /* Remember to restore stat attributes (owner, group, mode and times)
421 for the directory FILE_NAME, using information given in *ST,
422 once we stop extracting files into that directory.
424 If ST is null, merely create a placeholder node for an intermediate
425 directory that was created by make_directories.
427 NOTICE: this works only if the archive has usual member order, i.e.
428 directory, then the files in that directory. Incremental archive have
429 somewhat reversed order: first go subdirectories, then all other
430 members. To help cope with this case the variable
431 delay_directory_restore_option is set by prepare_to_extract.
433 If an archive was explicitely created so that its member order is
434 reversed, some directory timestamps can be restored incorrectly,
436 tar --no-recursion -cf archive dir dir/file1 foo dir/file2
439 delay_set_stat (char const *file_name, struct tar_stat_info const *st,
440 mode_t current_mode, mode_t current_mode_mask,
441 mode_t mode, int atflag)
443 size_t file_name_len = strlen (file_name);
444 struct delayed_set_stat *data =
445 xmalloc (offsetof (struct delayed_set_stat, file_name)
446 + file_name_len + 1);
447 data->next = delayed_set_stat_head;
451 data->dev = st->stat.st_dev;
452 data->ino = st->stat.st_ino;
453 data->uid = st->stat.st_uid;
454 data->gid = st->stat.st_gid;
455 data->atime = st->atime;
456 data->mtime = st->mtime;
458 data->file_name_len = file_name_len;
459 data->current_mode = current_mode;
460 data->current_mode_mask = current_mode_mask;
461 data->interdir = ! st;
462 data->atflag = atflag;
463 data->after_links = 0;
464 data->change_dir = chdir_current;
465 data->cntx_name = NULL;
467 assign_string (&data->cntx_name, st->cntx_name);
468 if (st && st->acls_a_ptr)
470 data->acls_a_ptr = xmemdup (st->acls_a_ptr, st->acls_a_len + 1);
471 data->acls_a_len = st->acls_a_len;
475 data->acls_a_ptr = NULL;
476 data->acls_a_len = 0;
478 if (st && st->acls_d_ptr)
480 data->acls_d_ptr = xmemdup (st->acls_d_ptr, st->acls_d_len + 1);
481 data->acls_d_len = st->acls_d_len;
485 data->acls_d_ptr = NULL;
486 data->acls_d_len = 0;
489 xheader_xattr_copy (st, &data->xattr_map, &data->xattr_map_size);
492 data->xattr_map = NULL;
493 data->xattr_map_size = 0;
495 strcpy (data->file_name, file_name);
496 delayed_set_stat_head = data;
497 if (must_be_dot_or_slash (file_name))
498 mark_after_links (data);
501 /* Update the delayed_set_stat info for an intermediate directory
502 created within the file name of DIR. The intermediate directory turned
503 out to be the same as this directory, e.g. due to ".." or symbolic
504 links. *DIR_STAT_INFO is the status of the directory. */
506 repair_delayed_set_stat (char const *dir,
507 struct stat const *dir_stat_info)
509 struct delayed_set_stat *data;
510 for (data = delayed_set_stat_head; data; data = data->next)
513 if (fstatat (chdir_fd, data->file_name, &st, data->atflag) != 0)
515 stat_error (data->file_name);
519 if (st.st_dev == dir_stat_info->st_dev
520 && st.st_ino == dir_stat_info->st_ino)
522 data->dev = current_stat_info.stat.st_dev;
523 data->ino = current_stat_info.stat.st_ino;
524 data->mode = current_stat_info.stat.st_mode;
525 data->uid = current_stat_info.stat.st_uid;
526 data->gid = current_stat_info.stat.st_gid;
527 data->atime = current_stat_info.atime;
528 data->mtime = current_stat_info.mtime;
529 data->current_mode = st.st_mode;
530 data->current_mode_mask = ALL_MODE_BITS;
531 data->interdir = false;
536 ERROR ((0, 0, _("%s: Unexpected inconsistency when making directory"),
537 quotearg_colon (dir)));
540 /* After a file/link/directory creation has failed, see if
541 it's because some required directory was not present, and if so,
542 create all required directories. Return zero if all the required
543 directories were created, nonzero (issuing a diagnostic) otherwise.
544 Set *INTERDIR_MADE if at least one directory was created. */
546 make_directories (char *file_name, bool *interdir_made)
548 char *cursor0 = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
549 char *cursor; /* points into the file name */
551 for (cursor = cursor0; *cursor; cursor++)
557 if (! ISSLASH (*cursor))
560 /* Avoid mkdir of empty string, if leading or double '/'. */
562 if (cursor == cursor0 || ISSLASH (cursor[-1]))
565 /* Avoid mkdir where last part of file name is "." or "..". */
567 if (cursor[-1] == '.'
568 && (cursor == cursor0 + 1 || ISSLASH (cursor[-2])
569 || (cursor[-2] == '.'
570 && (cursor == cursor0 + 2 || ISSLASH (cursor[-3])))))
573 *cursor = '\0'; /* truncate the name there */
574 desired_mode = MODE_RWX & ~ newdir_umask;
575 mode = desired_mode | (we_are_root ? 0 : MODE_WXUSR);
576 status = mkdirat (chdir_fd, file_name, mode);
580 /* Create a struct delayed_set_stat even if
581 mode == desired_mode, because
582 repair_delayed_set_stat may need to update the struct. */
583 delay_set_stat (file_name,
584 0, mode & ~ current_umask, MODE_RWX,
585 desired_mode, AT_SYMLINK_NOFOLLOW);
587 print_for_mkdir (file_name, cursor - file_name, desired_mode);
588 *interdir_made = true;
590 else if (errno == EEXIST)
594 /* Check whether the desired file exists. Even when the
595 file exists, mkdir can fail with some errno value E other
596 than EEXIST, so long as E describes an error condition
597 that also applies. */
600 status = fstatat (chdir_fd, file_name, &st, 0);
604 mkdir_error (file_name);
616 /* Return true if FILE_NAME (with status *STP, if STP) is not a
617 directory, and has a time stamp newer than (or equal to) that of
620 file_newer_p (const char *file_name, struct stat const *stp,
621 struct tar_stat_info *tar_stat)
627 if (deref_stat (file_name, &st) != 0)
631 stat_warn (file_name);
632 /* Be safer: if the file exists, assume it is newer. */
640 return (! S_ISDIR (stp->st_mode)
641 && tar_timespec_cmp (tar_stat->mtime, get_stat_mtime (stp)) <= 0);
646 #define RECOVER_SKIP 2
648 /* Attempt repairing what went wrong with the extraction. Delete an
649 already existing file or create missing intermediate directories.
650 Return RECOVER_OK if we somewhat increased our chances at a successful
651 extraction, RECOVER_NO if there are no chances, and RECOVER_SKIP if the
652 caller should skip extraction of that member. The value of errno is
653 properly restored on returning RECOVER_NO.
655 If REGULAR, the caller was trying to extract onto a regular file.
657 Set *INTERDIR_MADE if an intermediate directory is made as part of
658 the recovery process. */
661 maybe_recoverable (char *file_name, bool regular, bool *interdir_made)
665 struct stat const *stp = 0;
674 /* With open ("symlink", O_NOFOLLOW|...), POSIX says errno == ELOOP,
675 but some operating systems do not conform to the standard. */
677 /* NetBSD uses errno == EFTYPE; see <http://gnats.netbsd.org/43154>. */
680 /* FreeBSD 8.1 uses errno == EMLINK. */
682 /* Tru64 5.1B uses errno == ENOTSUP. */
686 || old_files_option != OVERWRITE_OLD_FILES || dereference_option)
688 if (strchr (file_name, '/'))
690 if (deref_stat (file_name, &st) != 0)
695 /* The caller tried to open a symbolic link with O_NOFOLLOW.
696 Fall through, treating it as an already-existing file. */
699 /* Remove an old file, if the options allow this. */
701 switch (old_files_option)
704 WARNOPT (WARN_EXISTING_FILE,
705 (0, 0, _("%s: skipping existing file"), file_name));
711 case KEEP_NEWER_FILES:
712 if (file_newer_p (file_name, stp, ¤t_stat_info))
716 case DEFAULT_OLD_FILES:
717 case NO_OVERWRITE_DIR_OLD_FILES:
718 case OVERWRITE_OLD_FILES:
719 if (0 < remove_any_file (file_name, ORDINARY_REMOVE_OPTION))
723 case UNLINK_FIRST_OLD_FILES:
728 /* Attempt creating missing intermediate directories. */
729 if (make_directories (file_name, interdir_made) == 0 && *interdir_made)
734 /* Just say we can't do anything about it... */
742 /* Restore stat extended attributes (xattr) for FILE_NAME, using information
743 given in *ST. Restore before extraction because they may affect file layout
744 (e.g. on Lustre distributed parallel filesystem - setting info about how many
745 servers is this file striped over, stripe size, mirror copies, etc.
746 in advance dramatically improves the following performance of reading and
747 writing a file). If not restoring permissions, invert the INVERT_PERMISSIONS
748 bits from the file's current permissions. TYPEFLAG specifies the type of the
749 file. FILE_CREATED indicates set_xattr has created the file */
751 set_xattr (char const *file_name, struct tar_stat_info const *st,
752 mode_t invert_permissions, char typeflag, int *file_created)
757 bool interdir_made = false;
759 if ((xattrs_option > 0) && st->xattr_map_size)
761 mode_t mode = current_stat_info.stat.st_mode & MODE_RWX & ~ current_umask;
764 status = mknodat (chdir_fd, file_name, mode ^ invert_permissions, 0);
765 while (status && maybe_recoverable ((char *)file_name, false,
768 xattrs_xattrs_set (st, file_name, typeflag, 0);
776 /* Fix the statuses of all directories whose statuses need fixing, and
777 which are not ancestors of FILE_NAME. If AFTER_LINKS is
778 nonzero, do this for all such directories; otherwise, stop at the
779 first directory that is marked to be fixed up only after delayed
780 links are applied. */
782 apply_nonancestor_delayed_set_stat (char const *file_name, bool after_links)
784 size_t file_name_len = strlen (file_name);
785 bool check_for_renamed_directories = 0;
787 while (delayed_set_stat_head)
789 struct delayed_set_stat *data = delayed_set_stat_head;
790 bool skip_this_one = 0;
792 mode_t current_mode = data->current_mode;
793 mode_t current_mode_mask = data->current_mode_mask;
795 check_for_renamed_directories |= data->after_links;
797 if (after_links < data->after_links
798 || (data->file_name_len < file_name_len
799 && file_name[data->file_name_len]
800 && (ISSLASH (file_name[data->file_name_len])
801 || ISSLASH (file_name[data->file_name_len - 1]))
802 && memcmp (file_name, data->file_name, data->file_name_len) == 0))
805 chdir_do (data->change_dir);
807 if (check_for_renamed_directories)
809 if (fstatat (chdir_fd, data->file_name, &st, data->atflag) != 0)
811 stat_error (data->file_name);
816 current_mode = st.st_mode;
817 current_mode_mask = ALL_MODE_BITS;
818 if (! (st.st_dev == data->dev && st.st_ino == data->ino))
821 _("%s: Directory renamed before its status could be extracted"),
822 quotearg_colon (data->file_name)));
830 struct tar_stat_info sb;
831 sb.stat.st_mode = data->mode;
832 sb.stat.st_uid = data->uid;
833 sb.stat.st_gid = data->gid;
834 sb.atime = data->atime;
835 sb.mtime = data->mtime;
836 sb.cntx_name = data->cntx_name;
837 sb.acls_a_ptr = data->acls_a_ptr;
838 sb.acls_a_len = data->acls_a_len;
839 sb.acls_d_ptr = data->acls_d_ptr;
840 sb.acls_d_len = data->acls_d_len;
841 sb.xattr_map = data->xattr_map;
842 sb.xattr_map_size = data->xattr_map_size;
843 set_stat (data->file_name, &sb,
844 -1, current_mode, current_mode_mask,
845 DIRTYPE, data->interdir, data->atflag);
848 delayed_set_stat_head = data->next;
849 xheader_xattr_free (data->xattr_map, data->xattr_map_size);
850 free (data->cntx_name);
851 free (data->acls_a_ptr);
852 free (data->acls_d_ptr);
859 is_directory_link (const char *file_name)
865 res = (fstatat (chdir_fd, file_name, &st, AT_SYMLINK_NOFOLLOW) == 0 &&
866 S_ISLNK (st.st_mode) &&
867 fstatat (chdir_fd, file_name, &st, 0) == 0 &&
868 S_ISDIR (st.st_mode));
873 /* Extractor functions for various member types */
876 extract_dir (char *file_name, int typeflag)
880 mode_t current_mode = 0;
881 mode_t current_mode_mask = 0;
883 bool interdir_made = false;
885 /* Save 'root device' to avoid purging mount points. */
886 if (one_file_system_option && root_device == 0)
890 if (fstatat (chdir_fd, ".", &st, 0) != 0)
893 root_device = st.st_dev;
896 if (incremental_option)
897 /* Read the entry and delete files that aren't listed in the archive. */
898 purge_directory (file_name);
899 else if (typeflag == GNUTYPE_DUMPDIR)
902 /* If ownership or permissions will be restored later, create the
903 directory with restrictive permissions at first, so that in the
904 meantime processes owned by other users do not inadvertently
905 create files under this directory that inherit the wrong owner,
906 group, or permissions from the directory. If not root, though,
907 make the directory writeable and searchable at first, so that
908 files can be created under it. */
909 mode = ((current_stat_info.stat.st_mode
910 & (0 < same_owner_option || 0 < same_permissions_option
913 | (we_are_root ? 0 : MODE_WXUSR));
917 status = mkdirat (chdir_fd, file_name, mode);
920 current_mode = mode & ~ current_umask;
921 current_mode_mask = MODE_RWX;
922 atflag = AT_SYMLINK_NOFOLLOW;
928 || keep_directory_symlink_option
929 || old_files_option == DEFAULT_OLD_FILES
930 || old_files_option == OVERWRITE_OLD_FILES))
934 if (keep_directory_symlink_option && is_directory_link (file_name))
937 if (deref_stat (file_name, &st) == 0)
939 current_mode = st.st_mode;
940 current_mode_mask = ALL_MODE_BITS;
942 if (S_ISDIR (current_mode))
946 repair_delayed_set_stat (file_name, &st);
955 switch (maybe_recoverable (file_name, false, &interdir_made))
966 mkdir_error (file_name);
975 || old_files_option == DEFAULT_OLD_FILES
976 || old_files_option == OVERWRITE_OLD_FILES)
977 delay_set_stat (file_name, ¤t_stat_info,
978 current_mode, current_mode_mask,
979 current_stat_info.stat.st_mode, atflag);
986 open_output_file (char const *file_name, int typeflag, mode_t mode,
987 int file_created, mode_t *current_mode,
988 mode_t *current_mode_mask)
991 bool overwriting_old_files = old_files_option == OVERWRITE_OLD_FILES;
992 int openflag = (O_WRONLY | O_BINARY | O_CLOEXEC | O_NOCTTY | O_NONBLOCK
994 | (overwriting_old_files
995 ? O_TRUNC | (dereference_option ? 0 : O_NOFOLLOW)
998 /* File might be created in set_xattr. So clear O_EXCL to avoid open() fail */
1000 openflag = openflag & ~O_EXCL;
1002 if (typeflag == CONTTYPE)
1004 static int conttype_diagnosed;
1006 if (!conttype_diagnosed)
1008 conttype_diagnosed = 1;
1009 WARNOPT (WARN_CONTIGUOUS_CAST,
1010 (0, 0, _("Extracting contiguous files as regular files")));
1014 /* If O_NOFOLLOW is needed but does not work, check for a symlink
1015 separately. There's a race condition, but that cannot be avoided
1016 on hosts lacking O_NOFOLLOW. */
1017 if (! HAVE_WORKING_O_NOFOLLOW
1018 && overwriting_old_files && ! dereference_option)
1021 if (fstatat (chdir_fd, file_name, &st, AT_SYMLINK_NOFOLLOW) == 0
1022 && S_ISLNK (st.st_mode))
1029 fd = openat (chdir_fd, file_name, openflag, mode);
1032 if (overwriting_old_files)
1035 if (fstat (fd, &st) != 0)
1042 if (! S_ISREG (st.st_mode))
1048 *current_mode = st.st_mode;
1049 *current_mode_mask = ALL_MODE_BITS;
1053 *current_mode = mode & ~ current_umask;
1054 *current_mode_mask = MODE_RWX;
1062 extract_file (char *file_name, int typeflag)
1066 union block *data_block;
1070 bool interdir_made = false;
1071 mode_t mode = (current_stat_info.stat.st_mode & MODE_RWX
1072 & ~ (0 < same_owner_option ? S_IRWXG | S_IRWXO : 0));
1073 mode_t invert_permissions = 0 < same_owner_option ? mode & (S_IRWXG | S_IRWXO)
1075 mode_t current_mode = 0;
1076 mode_t current_mode_mask = 0;
1078 if (to_stdout_option)
1080 else if (to_command_option)
1082 fd = sys_exec_command (file_name, 'f', ¤t_stat_info);
1091 int file_created = 0;
1092 if (set_xattr (file_name, ¤t_stat_info, invert_permissions,
1093 typeflag, &file_created))
1096 open_error (file_name);
1100 while ((fd = open_output_file (file_name, typeflag, mode,
1101 file_created, ¤t_mode,
1102 ¤t_mode_mask))
1105 int recover = maybe_recoverable (file_name, true, &interdir_made);
1106 if (recover != RECOVER_OK)
1109 if (recover == RECOVER_SKIP)
1111 open_error (file_name);
1117 mv_begin_read (¤t_stat_info);
1118 if (current_stat_info.is_sparse)
1119 sparse_extract_file (fd, ¤t_stat_info, &size);
1121 for (size = current_stat_info.stat.st_size; size > 0; )
1123 mv_size_left (size);
1125 /* Locate data, determine max length writeable, write it,
1126 block that we have used the data, then check if the write
1129 data_block = find_next_block ();
1132 ERROR ((0, 0, _("Unexpected EOF in archive")));
1133 break; /* FIXME: What happens, then? */
1136 written = available_space_after (data_block);
1141 count = blocking_write (fd, data_block->buffer, written);
1144 set_next_block_after ((union block *)
1145 (data_block->buffer + written - 1));
1146 if (count != written)
1148 if (!to_command_option)
1149 write_error_details (file_name, count, written);
1150 /* FIXME: shouldn't we restore from backup? */
1159 /* If writing to stdout, don't try to do anything to the filename;
1160 it doesn't exist, or we don't want to touch it anyway. */
1162 if (to_stdout_option)
1165 if (! to_command_option)
1166 set_stat (file_name, ¤t_stat_info, fd,
1167 current_mode, current_mode_mask, typeflag, false,
1168 (old_files_option == OVERWRITE_OLD_FILES
1169 ? 0 : AT_SYMLINK_NOFOLLOW));
1171 status = close (fd);
1173 close_error (file_name);
1175 if (to_command_option)
1176 sys_wait_command ();
1181 /* Create a placeholder file with name FILE_NAME, which will be
1182 replaced after other extraction is done by a symbolic link if
1183 IS_SYMLINK is true, and by a hard link otherwise. Set
1184 *INTERDIR_MADE if an intermediate directory is made in the
1188 create_placeholder_file (char *file_name, bool is_symlink, bool *interdir_made)
1193 while ((fd = openat (chdir_fd, file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0)
1195 switch (maybe_recoverable (file_name, false, interdir_made))
1204 open_error (file_name);
1209 if (fstat (fd, &st) != 0)
1211 stat_error (file_name);
1214 else if (close (fd) != 0)
1215 close_error (file_name);
1218 struct delayed_set_stat *h;
1219 struct delayed_link *p =
1220 xmalloc (offsetof (struct delayed_link, target)
1221 + strlen (current_stat_info.link_name)
1223 p->next = delayed_link_head;
1224 delayed_link_head = p;
1227 p->birthtime = get_stat_birthtime (&st);
1228 p->is_symlink = is_symlink;
1231 p->mode = current_stat_info.stat.st_mode;
1232 p->uid = current_stat_info.stat.st_uid;
1233 p->gid = current_stat_info.stat.st_gid;
1234 p->atime = current_stat_info.atime;
1235 p->mtime = current_stat_info.mtime;
1237 p->change_dir = chdir_current;
1238 p->sources = xmalloc (offsetof (struct string_list, string)
1239 + strlen (file_name) + 1);
1240 p->sources->next = 0;
1241 strcpy (p->sources->string, file_name);
1242 p->cntx_name = NULL;
1243 assign_string (&p->cntx_name, current_stat_info.cntx_name);
1244 p->acls_a_ptr = NULL;
1246 p->acls_d_ptr = NULL;
1248 xheader_xattr_copy (¤t_stat_info, &p->xattr_map, &p->xattr_map_size);
1249 strcpy (p->target, current_stat_info.link_name);
1251 h = delayed_set_stat_head;
1252 if (h && ! h->after_links
1253 && strncmp (file_name, h->file_name, h->file_name_len) == 0
1254 && ISSLASH (file_name[h->file_name_len])
1255 && (last_component (file_name) == file_name + h->file_name_len + 1))
1256 mark_after_links (h);
1265 extract_link (char *file_name, int typeflag)
1267 bool interdir_made = false;
1268 char const *link_name;
1271 link_name = current_stat_info.link_name;
1273 if (! absolute_names_option && contains_dot_dot (link_name))
1274 return create_placeholder_file (file_name, false, &interdir_made);
1278 struct stat st1, st2;
1280 int status = linkat (chdir_fd, link_name, chdir_fd, file_name, 0);
1285 struct delayed_link *ds = delayed_link_head;
1287 && fstatat (chdir_fd, link_name, &st1, AT_SYMLINK_NOFOLLOW) == 0)
1288 for (; ds; ds = ds->next)
1289 if (ds->change_dir == chdir_current
1290 && ds->dev == st1.st_dev
1291 && ds->ino == st1.st_ino
1292 && (timespec_cmp (ds->birthtime, get_stat_birthtime (&st1))
1295 struct string_list *p = xmalloc (offsetof (struct string_list, string)
1296 + strlen (file_name) + 1);
1297 strcpy (p->string, file_name);
1298 p->next = ds->sources;
1304 else if ((e == EEXIST && strcmp (link_name, file_name) == 0)
1305 || ((fstatat (chdir_fd, link_name, &st1, AT_SYMLINK_NOFOLLOW)
1307 && (fstatat (chdir_fd, file_name, &st2, AT_SYMLINK_NOFOLLOW)
1309 && st1.st_dev == st2.st_dev
1310 && st1.st_ino == st2.st_ino))
1315 while ((rc = maybe_recoverable (file_name, false, &interdir_made))
1318 if (rc == RECOVER_SKIP)
1320 if (!(incremental_option && errno == EEXIST))
1322 link_error (link_name, file_name);
1329 extract_symlink (char *file_name, int typeflag)
1332 bool interdir_made = false;
1334 if (! absolute_names_option
1335 && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name)
1336 || contains_dot_dot (current_stat_info.link_name)))
1337 return create_placeholder_file (file_name, true, &interdir_made);
1339 while (symlinkat (current_stat_info.link_name, chdir_fd, file_name) != 0)
1340 switch (maybe_recoverable (file_name, false, &interdir_made))
1349 symlink_error (current_stat_info.link_name, file_name);
1353 set_stat (file_name, ¤t_stat_info, -1, 0, 0,
1354 SYMTYPE, false, AT_SYMLINK_NOFOLLOW);
1358 static int warned_once;
1363 WARNOPT (WARN_SYMLINK_CAST,
1365 _("Attempting extraction of symbolic links as hard links")));
1367 return extract_link (file_name, typeflag);
1371 #if S_IFCHR || S_IFBLK
1373 extract_node (char *file_name, int typeflag)
1375 bool interdir_made = false;
1376 mode_t mode = (current_stat_info.stat.st_mode & (MODE_RWX | S_IFBLK | S_IFCHR)
1377 & ~ (0 < same_owner_option ? S_IRWXG | S_IRWXO : 0));
1379 while (mknodat (chdir_fd, file_name, mode, current_stat_info.stat.st_rdev)
1381 switch (maybe_recoverable (file_name, false, &interdir_made))
1390 mknod_error (file_name);
1394 set_stat (file_name, ¤t_stat_info, -1,
1395 mode & ~ current_umask, MODE_RWX,
1396 typeflag, false, AT_SYMLINK_NOFOLLOW);
1401 #if HAVE_MKFIFO || defined mkfifo
1403 extract_fifo (char *file_name, int typeflag)
1405 bool interdir_made = false;
1406 mode_t mode = (current_stat_info.stat.st_mode & MODE_RWX
1407 & ~ (0 < same_owner_option ? S_IRWXG | S_IRWXO : 0));
1409 while (mkfifoat (chdir_fd, file_name, mode) != 0)
1410 switch (maybe_recoverable (file_name, false, &interdir_made))
1419 mkfifo_error (file_name);
1423 set_stat (file_name, ¤t_stat_info, -1,
1424 mode & ~ current_umask, MODE_RWX,
1425 typeflag, false, AT_SYMLINK_NOFOLLOW);
1431 extract_volhdr (char *file_name, int typeflag)
1438 extract_failure (char *file_name, int typeflag)
1444 extract_skip (char *file_name, int typeflag)
1450 typedef int (*tar_extractor_t) (char *file_name, int typeflag);
1454 /* Prepare to extract a file. Find extractor function.
1455 Return zero if extraction should not proceed. */
1458 prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun)
1462 if (EXTRACT_OVER_PIPE)
1465 /* Select the extractor */
1468 case GNUTYPE_SPARSE:
1469 *fun = extract_file;
1476 /* Appears to be a file. But BSD tar uses the convention that a slash
1477 suffix means a directory. */
1478 if (current_stat_info.had_trailing_slash)
1482 *fun = extract_file;
1488 *fun = extract_symlink;
1492 *fun = extract_link;
1497 current_stat_info.stat.st_mode |= S_IFCHR;
1498 *fun = extract_node;
1504 current_stat_info.stat.st_mode |= S_IFBLK;
1505 *fun = extract_node;
1509 #if HAVE_MKFIFO || defined mkfifo
1511 *fun = extract_fifo;
1516 case GNUTYPE_DUMPDIR:
1518 if (current_stat_info.is_dumpdir)
1519 delay_directory_restore_option = true;
1522 case GNUTYPE_VOLHDR:
1523 *fun = extract_volhdr;
1526 case GNUTYPE_MULTIVOL:
1528 _("%s: Cannot extract -- file is continued from another volume"),
1529 quotearg_colon (current_stat_info.file_name)));
1530 *fun = extract_skip;
1533 case GNUTYPE_LONGNAME:
1534 case GNUTYPE_LONGLINK:
1535 ERROR ((0, 0, _("Unexpected long name header")));
1536 *fun = extract_failure;
1540 WARNOPT (WARN_UNKNOWN_CAST,
1542 _("%s: Unknown file type '%c', extracted as normal file"),
1543 quotearg_colon (file_name), typeflag));
1544 *fun = extract_file;
1547 /* Determine whether the extraction should proceed */
1551 switch (old_files_option)
1553 case UNLINK_FIRST_OLD_FILES:
1554 if (!remove_any_file (file_name,
1555 recursive_unlink_option ? RECURSIVE_REMOVE_OPTION
1556 : ORDINARY_REMOVE_OPTION)
1557 && errno && errno != ENOENT)
1559 unlink_error (file_name);
1564 case KEEP_NEWER_FILES:
1565 if (file_newer_p (file_name, 0, ¤t_stat_info))
1567 WARNOPT (WARN_IGNORE_NEWER,
1568 (0, 0, _("Current %s is newer or same age"),
1569 quote (file_name)));
1581 /* Extract a file from the archive. */
1583 extract_archive (void)
1586 tar_extractor_t fun;
1588 fatal_exit_hook = extract_finish;
1590 set_next_block_after (current_header);
1592 if (!current_stat_info.file_name[0]
1593 || (interactive_option
1594 && !confirm ("extract", current_stat_info.file_name)))
1600 /* Print the block from current_header and current_stat. */
1602 print_header (¤t_stat_info, current_header, -1);
1604 /* Restore stats for all non-ancestor directories, unless
1605 it is an incremental archive.
1606 (see NOTICE in the comment to delay_set_stat above) */
1607 if (!delay_directory_restore_option)
1609 int dir = chdir_current;
1610 apply_nonancestor_delayed_set_stat (current_stat_info.file_name, 0);
1614 /* Take a safety backup of a previously existing file. */
1617 if (!maybe_backup_file (current_stat_info.file_name, 0))
1620 ERROR ((0, e, _("%s: Was unable to backup this file"),
1621 quotearg_colon (current_stat_info.file_name)));
1626 /* Extract the archive entry according to its type. */
1628 typeflag = sparse_member_p (¤t_stat_info) ?
1629 GNUTYPE_SPARSE : current_header->header.typeflag;
1631 if (prepare_to_extract (current_stat_info.file_name, typeflag, &fun))
1633 if (fun && (*fun) (current_stat_info.file_name, typeflag)
1635 undo_last_backup ();
1642 /* Extract the links whose final extraction were delayed. */
1644 apply_delayed_links (void)
1646 struct delayed_link *ds;
1648 for (ds = delayed_link_head; ds; )
1650 struct string_list *sources = ds->sources;
1651 char const *valid_source = 0;
1653 chdir_do (ds->change_dir);
1655 for (sources = ds->sources; sources; sources = sources->next)
1657 char const *source = sources->string;
1660 /* Make sure the placeholder file is still there. If not,
1661 don't create a link, as the placeholder was probably
1662 removed by a later extraction. */
1663 if (fstatat (chdir_fd, source, &st, AT_SYMLINK_NOFOLLOW) == 0
1664 && st.st_dev == ds->dev
1665 && st.st_ino == ds->ino
1666 && timespec_cmp (get_stat_birthtime (&st), ds->birthtime) == 0)
1668 /* Unlink the placeholder, then create a hard link if possible,
1669 a symbolic link otherwise. */
1670 if (unlinkat (chdir_fd, source, 0) != 0)
1671 unlink_error (source);
1672 else if (valid_source
1673 && (linkat (chdir_fd, valid_source, chdir_fd, source, 0)
1676 else if (!ds->is_symlink)
1678 if (linkat (chdir_fd, ds->target, chdir_fd, source, 0) != 0)
1679 link_error (ds->target, source);
1681 else if (symlinkat (ds->target, chdir_fd, source) != 0)
1682 symlink_error (ds->target, source);
1685 struct tar_stat_info st1;
1686 st1.stat.st_mode = ds->mode;
1687 st1.stat.st_uid = ds->uid;
1688 st1.stat.st_gid = ds->gid;
1689 st1.atime = ds->atime;
1690 st1.mtime = ds->mtime;
1691 st1.cntx_name = ds->cntx_name;
1692 st1.acls_a_ptr = ds->acls_a_ptr;
1693 st1.acls_a_len = ds->acls_a_len;
1694 st1.acls_d_ptr = ds->acls_d_ptr;
1695 st1.acls_d_len = ds->acls_d_len;
1696 st1.xattr_map = ds->xattr_map;
1697 st1.xattr_map_size = ds->xattr_map_size;
1698 set_stat (source, &st1, -1, 0, 0, SYMTYPE,
1699 false, AT_SYMLINK_NOFOLLOW);
1700 valid_source = source;
1705 for (sources = ds->sources; sources; )
1707 struct string_list *next = sources->next;
1712 xheader_xattr_free (ds->xattr_map, ds->xattr_map_size);
1713 free (ds->cntx_name);
1716 struct delayed_link *next = ds->next;
1722 delayed_link_head = 0;
1725 /* Finish the extraction of an archive. */
1727 extract_finish (void)
1729 /* First, fix the status of ordinary directories that need fixing. */
1730 apply_nonancestor_delayed_set_stat ("", 0);
1732 /* Then, apply delayed links, so that they don't affect delayed
1733 directory status-setting for ordinary directories. */
1734 apply_delayed_links ();
1736 /* Finally, fix the status of directories that are ancestors
1737 of delayed links. */
1738 apply_nonancestor_delayed_set_stat ("", 1);
1742 rename_directory (char *src, char *dst)
1744 if (renameat (chdir_fd, src, chdir_fd, dst) != 0)
1752 if (make_directories (dst, &interdir_made) == 0)
1754 if (renameat (chdir_fd, src, chdir_fd, dst) == 0)
1761 /* FIXME: Fall back to recursive copying */
1767 ERROR ((0, e, _("Cannot rename %s to %s"),