1 /* Extract files from a tar archive.
2 Copyright 1988, 92,93,94,96,97,98, 1999 Free Software Foundation, Inc.
3 Written by John Gilmore, on 1985-11-19.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any later
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
13 Public License for more details.
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
38 static time_t now; /* current time */
39 static int we_are_root; /* true if our effective uid == 0 */
40 static mode_t newdir_umask; /* umask when creating new directories */
41 static mode_t current_umask; /* current umask (which is set to 0 if -p) */
44 /* "Scratch" space to store the information about a sparse file before
45 writing the info into the header or extended header. */
46 struct sp_array *sparsearray;
48 /* Number of elts storable in the sparsearray. */
49 int sp_array_size = 10;
52 struct delayed_set_stat
54 struct delayed_set_stat *next;
56 struct stat stat_info;
59 static struct delayed_set_stat *delayed_set_stat_head;
61 /*--------------------------.
62 | Set up to extract files. |
63 `--------------------------*/
69 we_are_root = geteuid () == 0;
71 /* Option -p clears the kernel umask, so it does not affect proper
72 restoration of file permissions. New intermediate directories will
73 comply with umask at start of program. */
75 newdir_umask = umask (0);
76 if (same_permissions_option)
80 umask (newdir_umask); /* restore the kernel umask */
81 current_umask = newdir_umask;
84 /* FIXME: Just make sure we can add files in directories we create. Maybe
85 should we later remove permissions we are adding, here? */
86 newdir_umask &= ~ MODE_WXUSR;
89 /*------------------------------------------------------------------.
90 | Restore mode for FILE_NAME, from information given in STAT_INFO. |
91 `------------------------------------------------------------------*/
94 set_mode (char *file_name, struct stat *stat_info)
96 /* Do nothing unless we are restoring the original permissions.
98 We must force permission when -k and -U are not selected, because if the
99 file already existed, open or creat would save the permission bits from
100 the previously created file, ignoring the ones we specified.
102 But with -k or -U selected, we know *we* created this file, so the mode
103 bits were set by our open. If the file has abnormal mode bits, we must
104 chmod since writing or chown has probably reset them. If the file is
105 normal, we merely skip the chmod. This works because we did umask (0)
106 when -p, so umask will have left the specified mode alone. */
108 if ((we_are_root || same_permissions_option)
109 && ((!keep_old_files_option && !unlink_first_option)
110 || (stat_info->st_mode & (S_ISUID | S_ISGID | S_ISVTX))))
111 if (chmod (file_name, ~current_umask & stat_info->st_mode) < 0)
112 ERROR ((0, errno, _("%s: Cannot change mode to %04lo"),
114 (unsigned long) (~current_umask & stat_info->st_mode)));
117 /*----------------------------------------------------------------------.
118 | Restore stat attributes (owner, group, mode and times) for FILE_NAME, |
119 | using information given in STAT_INFO. SYMLINK_FLAG is non-zero for a |
120 | freshly restored symbolic link. |
121 `----------------------------------------------------------------------*/
123 /* FIXME: About proper restoration of symbolic link attributes, we still do
124 not have it right. Pretesters' reports tell us we need further study and
125 probably more configuration. For now, just use lchown if it exists, and
126 punt for the rest. Sigh! */
129 set_stat (char *file_name, struct stat *stat_info, int symlink_flag)
131 struct utimbuf utimbuf;
135 /* We do the utime before the chmod because some versions of utime are
136 broken and trash the modes of the file. */
140 /* We set the accessed time to `now', which is really the time we
141 started extracting files, unless incremental_option is used, in
142 which case .st_atime is used. */
144 /* FIXME: incremental_option should set ctime too, but how? */
146 if (incremental_option)
147 utimbuf.actime = stat_info->st_atime;
149 utimbuf.actime = now;
151 utimbuf.modtime = stat_info->st_mtime;
153 if (utime (file_name, &utimbuf) < 0)
155 _("%s: Could not change access and modification times"),
159 /* Some systems allow non-root users to give files away. Once this
160 done, it is not possible anymore to change file permissions, so we
161 have to set permissions prior to possibly giving files away. */
163 set_mode (file_name, stat_info);
166 /* If we are root, set the owner and group of the extracted file, so we
167 extract as the original owner. Or else, if we are running as a user,
168 leave the owner and group as they are, so we extract as that user. */
170 if (we_are_root || same_owner_option)
174 /* When lchown exists, it should be used to change the attributes of
175 the symbolic link itself. In this case, a mere chown would change
176 the attributes of the file the symbolic link is pointing to, and
177 should be avoided. */
181 if (lchown (file_name, stat_info->st_uid, stat_info->st_gid) < 0)
182 ERROR ((0, errno, _("%s: Cannot lchown to uid %lu gid %lu"),
184 (unsigned long) stat_info->st_uid,
185 (unsigned long) stat_info->st_gid));
189 if (chown (file_name, stat_info->st_uid, stat_info->st_gid) < 0)
190 ERROR ((0, errno, _("%s: Cannot chown to uid %lu gid %lu"),
192 (unsigned long) stat_info->st_uid,
193 (unsigned long) stat_info->st_gid));
196 #else /* not HAVE_LCHOWN */
200 if (chown (file_name, stat_info->st_uid, stat_info->st_gid) < 0)
201 ERROR ((0, errno, _("%s: Cannot chown to uid %lu gid %lu"),
203 (unsigned long) stat_info->st_uid,
204 (unsigned long) stat_info->st_gid));
206 #endif/* not HAVE_LCHOWN */
210 /* On a few systems, and in particular, those allowing to give files
211 away, changing the owner or group destroys the suid or sgid bits.
212 So let's attempt setting these bits once more. */
214 if (stat_info->st_mode & (S_ISUID | S_ISGID | S_ISVTX))
215 set_mode (file_name, stat_info);
219 /*-----------------------------------------------------------------------.
220 | After a file/link/symlink/directory creation has failed, see if it's |
221 | because some required directory was not present, and if so, create all |
222 | required directories. Return non-zero if a directory was created. |
223 `-----------------------------------------------------------------------*/
226 make_directories (char *file_name)
228 char *cursor; /* points into path */
229 int did_something = 0; /* did we do anything yet? */
230 int saved_errno = errno; /* remember caller's errno */
233 for (cursor = strchr (file_name, '/');
235 cursor = strchr (cursor + 1, '/'))
237 /* Avoid mkdir of empty string, if leading or double '/'. */
239 if (cursor == file_name || cursor[-1] == '/')
242 /* Avoid mkdir where last part of path is '.'. */
244 if (cursor[-1] == '.' && (cursor == file_name + 1 || cursor[-2] == '/'))
247 *cursor = '\0'; /* truncate the path there */
248 status = mkdir (file_name, ~newdir_umask & MODE_RWX);
252 print_for_mkdir (file_name, cursor - file_name,
253 ~newdir_umask & MODE_RWX);
264 /* Turbo C mkdir gives a funny errno. */
268 /* Directory already exists. */
271 /* Some other error in the mkdir. We return to the caller. */
275 errno = saved_errno; /* FIXME: errno should be read-only */
276 return did_something; /* tell them to retry if we made one */
279 /*--------------------------------------------------------------------.
280 | Unlink the destination, if we are supposed to do so. |
281 | Return zero if extraction should not proceed. |
282 `--------------------------------------------------------------------*/
285 unlink_destination (char const *file_name)
287 if (unlink_first_option
288 && !remove_any_file (file_name, recursive_unlink_option)
291 ERROR ((0, errno, _("Cannot remove %s"), file_name));
298 /*--------------------------------------------------------------------.
299 | Attempt repairing what went wrong with the extraction. Delete an |
300 | already existing file or create missing intermediate directories. |
301 | Return nonzero if we somewhat increased our chances at a successful |
302 | extraction. errno is properly restored on zero return. |
303 `--------------------------------------------------------------------*/
306 maybe_recoverable (char *file_name)
311 /* Attempt deleting an existing file. However, with -k or -U, just stay
314 if (keep_old_files_option || unlink_first_option)
317 return remove_any_file (file_name, 0);
320 /* Attempt creating missing intermediate directories. */
322 return make_directories (file_name);
325 /* Just say we can't do anything about it... */
336 extract_sparse_file (int fd, off_t *sizeleft, off_t totalsize, char *name)
342 /* assuming sizeleft is initially totalsize */
344 while (*sizeleft > 0)
346 union block *data_block = find_next_block ();
347 if (data_block == NULL)
349 ERROR ((0, 0, _("Unexpected EOF on archive file")));
352 if (lseek (fd, sparsearray[sparse_ind].offset, SEEK_SET) < 0)
354 char buf[UINTMAX_STRSIZE_BOUND];
355 ERROR ((0, errno, _("%s: lseek error at byte %s"),
356 STRINGIFY_BIGINT (sparsearray[sparse_ind].offset, buf),
360 written = sparsearray[sparse_ind++].numbytes;
361 while (written > BLOCKSIZE)
363 count = full_write (fd, data_block->buffer, BLOCKSIZE);
365 ERROR ((0, errno, _("%s: Could not write to file"), name));
368 set_next_block_after (data_block);
369 data_block = find_next_block ();
372 ERROR ((0, 0, _("Unexpected EOF on archive file")));
377 count = full_write (fd, data_block->buffer, written);
380 ERROR ((0, errno, _("%s: Could not write to file"), name));
381 else if (count != written)
383 char buf1[UINTMAX_STRSIZE_BOUND];
384 char buf2[UINTMAX_STRSIZE_BOUND];
385 ERROR ((0, 0, _("%s: Could only write %s of %s bytes"),
387 STRINGIFY_BIGINT (totalsize - *sizeleft, buf1),
388 STRINGIFY_BIGINT (totalsize, buf2)));
389 skip_file (*sizeleft);
394 set_next_block_after (data_block);
400 /*----------------------------------.
401 | Extract a file from the archive. |
402 `----------------------------------*/
405 extract_archive (void)
407 union block *data_block;
422 struct delayed_set_stat *data;
424 #define CURRENT_FILE_NAME (skipcrud + current_file_name)
426 set_next_block_after (current_header);
427 decode_header (current_header, ¤t_stat, ¤t_format, 1);
429 if (interactive_option && !confirm ("extract", current_file_name))
431 if (current_header->oldgnu_header.isextended)
432 skip_extended_headers ();
433 skip_file (current_stat.st_size);
437 /* Print the block from `current_header' and `current_stat'. */
442 /* Check for fully specified file names and other atrocities. */
445 while (!absolute_names_option && CURRENT_FILE_NAME[0] == '/')
447 static int warned_once;
452 WARN ((0, 0, _("Removing leading `/' from archive names")));
454 skipcrud++; /* force relative path */
457 /* Take a safety backup of a previously existing file. */
459 if (backup_option && !to_stdout_option)
460 if (!maybe_backup_file (CURRENT_FILE_NAME, 0))
462 ERROR ((0, errno, _("%s: Was unable to backup this file"),
464 if (current_header->oldgnu_header.isextended)
465 skip_extended_headers ();
466 skip_file (current_stat.st_size);
470 /* Extract the archive entry according to its type. */
472 typeflag = current_header->header.typeflag;
475 /* JK - What we want to do if the file is sparse is loop through
476 the array of sparse structures in the header and read in and
477 translate the character strings representing 1) the offset at
478 which to write and 2) how many bytes to write into numbers,
479 which we store into the scratch array, "sparsearray". This
480 array makes our life easier the same way it did in creating the
481 tar file that had to deal with a sparse file.
483 After we read in the first five (at most) sparse structures, we
484 check to see if the file has an extended header, i.e., if more
485 sparse structures are needed to describe the contents of the new
486 file. If so, we read in the extended headers and continue to
487 store their contents into the sparsearray. */
491 sparsearray = (struct sp_array *)
492 xmalloc (sp_array_size * sizeof (struct sp_array));
494 for (counter = 0; counter < SPARSES_IN_OLDGNU_HEADER; counter++)
496 sparsearray[counter].offset =
497 OFF_FROM_CHARS (current_header->oldgnu_header.sp[counter].offset);
498 sparsearray[counter].numbytes =
499 SIZE_FROM_CHARS (current_header->oldgnu_header.sp[counter].numbytes);
500 if (!sparsearray[counter].numbytes)
504 if (current_header->oldgnu_header.isextended)
506 /* Read in the list of extended headers and translate them
507 into the sparsearray as before. Note that this
508 invalidates current_header. */
510 /* static */ int ind = SPARSES_IN_OLDGNU_HEADER;
514 exhdr = find_next_block ();
517 ERROR ((0, 0, _("Unexpected EOF on archive file")));
520 for (counter = 0; counter < SPARSES_IN_SPARSE_HEADER; counter++)
522 if (counter + ind > sp_array_size - 1)
524 /* Realloc the scratch area since we've run out of
528 sparsearray = (struct sp_array *)
529 xrealloc (sparsearray,
530 sp_array_size * (sizeof (struct sp_array)));
532 if (exhdr->sparse_header.sp[counter].numbytes[0] == 0)
534 sparsearray[counter + ind].offset =
535 OFF_FROM_CHARS (exhdr->sparse_header.sp[counter].offset);
536 sparsearray[counter + ind].numbytes =
537 SIZE_FROM_CHARS (exhdr->sparse_header.sp[counter].numbytes);
539 if (!exhdr->sparse_header.isextended)
543 ind += SPARSES_IN_SPARSE_HEADER;
544 set_next_block_after (exhdr);
547 set_next_block_after (exhdr);
555 /* Appears to be a file. But BSD tar uses the convention that a slash
556 suffix means a directory. */
558 name_length = strlen (CURRENT_FILE_NAME) - 1;
559 if (CURRENT_FILE_NAME[name_length] == '/')
562 /* FIXME: deal with protection issues. */
565 openflag = (keep_old_files_option || unlink_first_option ?
566 O_WRONLY | O_BINARY | O_NONBLOCK | O_CREAT | O_EXCL :
567 O_WRONLY | O_BINARY | O_NONBLOCK | O_CREAT | O_TRUNC)
568 | ((typeflag == GNUTYPE_SPARSE) ? 0 : O_APPEND);
570 /* JK - The last | is a kludge to solve the problem the O_APPEND
571 flag causes with files we are trying to make sparse: when a file
572 is opened with O_APPEND, it writes to the last place that
573 something was written, thereby ignoring any lseeks that we have
574 done. We add this extra condition to make it able to lseek when
575 a file is sparse, i.e., we don't open the new file with this
576 flag. (Grump -- this bug caused me to waste a good deal of
577 time, I might add) */
579 if (to_stdout_option)
585 if (!unlink_destination (CURRENT_FILE_NAME))
587 if (current_header->oldgnu_header.isextended)
588 skip_extended_headers ();
589 skip_file (current_stat.st_size);
596 /* Contiguous files (on the Masscomp) have to specify the size in
597 the open call that creates them. */
599 if (typeflag == CONTTYPE)
600 fd = open (CURRENT_FILE_NAME, openflag | O_CTG,
601 current_stat.st_mode, current_stat.st_size);
603 fd = open (CURRENT_FILE_NAME, openflag, current_stat.st_mode);
605 #else /* not O_CTG */
606 if (typeflag == CONTTYPE)
608 static int conttype_diagnosed = 0;
610 if (!conttype_diagnosed)
612 conttype_diagnosed = 1;
613 WARN ((0, 0, _("Extracting contiguous files as regular files")));
616 fd = open (CURRENT_FILE_NAME, openflag, current_stat.st_mode);
618 #endif /* not O_CTG */
622 if (maybe_recoverable (CURRENT_FILE_NAME))
625 ERROR ((0, errno, _("%s: Could not create file"),
627 if (current_header->oldgnu_header.isextended)
628 skip_extended_headers ();
629 skip_file (current_stat.st_size);
636 if (typeflag == GNUTYPE_SPARSE)
639 size_t name_length_bis;
641 /* Kludge alert. NAME is assigned to header.name because
642 during the extraction, the space that contains the header
643 will get scribbled on, and the name will get munged, so any
644 error messages that happen to contain the filename will look
645 REAL interesting unless we do this. */
647 name_length_bis = strlen (CURRENT_FILE_NAME) + 1;
648 name = (char *) xmalloc (name_length_bis);
649 memcpy (name, CURRENT_FILE_NAME, name_length_bis);
650 size = current_stat.st_size;
651 extract_sparse_file (fd, &size, current_stat.st_size, name);
654 for (size = current_stat.st_size;
658 if (multi_volume_option)
660 assign_string (&save_name, current_file_name);
661 save_totsize = current_stat.st_size;
662 save_sizeleft = size;
665 /* Locate data, determine max length writeable, write it,
666 block that we have used the data, then check if the write
669 data_block = find_next_block ();
670 if (data_block == NULL)
672 ERROR ((0, 0, _("Unexpected EOF on archive file")));
673 break; /* FIXME: What happens, then? */
676 written = available_space_after (data_block);
680 errno = 0; /* FIXME: errno should be read-only */
681 sstatus = full_write (fd, data_block->buffer, written);
683 set_next_block_after ((union block *)
684 (data_block->buffer + written - 1));
685 if (sstatus == written)
688 /* Error in writing to file. Print it, skip to next file in
692 ERROR ((0, errno, _("%s: Could not write to file"),
695 ERROR ((0, 0, _("%s: Could only write %lu of %lu bytes"),
697 (unsigned long) sstatus,
698 (unsigned long) written));
699 skip_file (size - written);
700 break; /* still do the close, mod time, chmod, etc */
703 if (multi_volume_option)
704 assign_string (&save_name, NULL);
706 /* If writing to stdout, don't try to do anything to the filename;
707 it doesn't exist, or we don't want to touch it anyway. */
709 if (to_stdout_option)
715 ERROR ((0, errno, _("%s: Error while closing"), CURRENT_FILE_NAME));
720 set_stat (CURRENT_FILE_NAME, ¤t_stat, 0);
724 if (to_stdout_option)
728 if (!unlink_destination (CURRENT_FILE_NAME))
731 while (status = symlink (current_link_name, CURRENT_FILE_NAME),
733 if (!maybe_recoverable (CURRENT_FILE_NAME))
738 /* Setting the attributes of symbolic links might, on some systems,
739 change the pointed to file, instead of the symbolic link itself.
740 At least some of these systems have a lchown call, and the
741 set_stat routine knows about this. */
743 set_stat (CURRENT_FILE_NAME, ¤t_stat, 1);
747 ERROR ((0, errno, _("%s: Could not create symlink to `%s'"),
748 CURRENT_FILE_NAME, current_link_name));
756 static int warned_once = 0;
762 _("Attempting extraction of symbolic links as hard links")));
770 if (to_stdout_option)
773 if (!unlink_destination (CURRENT_FILE_NAME))
778 struct stat st1, st2;
780 /* MSDOS does not implement links. However, djgpp's link() actually
782 status = link (current_link_name, CURRENT_FILE_NAME);
786 if (maybe_recoverable (CURRENT_FILE_NAME))
789 if (incremental_option && errno == EEXIST)
791 if (stat (current_link_name, &st1) == 0
792 && stat (CURRENT_FILE_NAME, &st2) == 0
793 && st1.st_dev == st2.st_dev
794 && st1.st_ino == st2.st_ino)
797 ERROR ((0, errno, _("%s: Could not link to `%s'"),
798 CURRENT_FILE_NAME, current_link_name));
806 current_stat.st_mode |= S_IFCHR;
812 current_stat.st_mode |= S_IFBLK;
815 #if S_IFCHR || S_IFBLK
817 if (to_stdout_option)
820 if (!unlink_destination (CURRENT_FILE_NAME))
823 status = mknod (CURRENT_FILE_NAME, current_stat.st_mode,
824 current_stat.st_rdev);
827 if (maybe_recoverable (CURRENT_FILE_NAME))
830 ERROR ((0, errno, _("%s: Could not make node"), CURRENT_FILE_NAME));
835 set_stat (CURRENT_FILE_NAME, ¤t_stat, 0);
839 #if HAVE_MKFIFO || defined mkfifo
841 if (to_stdout_option)
844 if (!unlink_destination (CURRENT_FILE_NAME))
847 while (status = mkfifo (CURRENT_FILE_NAME, current_stat.st_mode),
849 if (!maybe_recoverable (CURRENT_FILE_NAME))
853 set_stat (CURRENT_FILE_NAME, ¤t_stat, 0);
856 ERROR ((0, errno, _("%s: Could not make fifo"), CURRENT_FILE_NAME));
864 case GNUTYPE_DUMPDIR:
865 name_length = strlen (CURRENT_FILE_NAME) - 1;
868 /* Check for trailing /, and zap as many as we find. */
869 while (name_length && CURRENT_FILE_NAME[name_length] == '/')
870 CURRENT_FILE_NAME[name_length--] = '\0';
872 if (incremental_option)
874 /* Read the entry and delete files that aren't listed in the
877 gnu_restore (skipcrud);
879 else if (typeflag == GNUTYPE_DUMPDIR)
880 skip_file (current_stat.st_size);
882 if (to_stdout_option)
886 status = mkdir (CURRENT_FILE_NAME,
887 ((we_are_root ? 0 : MODE_WXUSR)
888 | current_stat.st_mode));
891 /* If the directory creation fails, let's consider immediately the
892 case where the directory already exists. We have three good
893 reasons for clearing out this case before attempting recovery.
895 1) It would not be efficient recovering the error by deleting
896 the directory in maybe_recoverable, then recreating it right
897 away. We only hope we will be able to adjust its permissions
900 2) Removing the directory might fail if it is not empty. By
901 exception, this real error is traditionally not reported.
903 3) Let's suppose `DIR' already exists and we are about to
904 extract `DIR/../DIR'. This would fail because the directory
905 already exists, and maybe_recoverable would react by removing
906 `DIR'. This then would fail again because there are missing
907 intermediate directories, and maybe_recoverable would react by
908 creating `DIR'. We would then have an extraction loop. */
913 int saved_errno = errno;
915 if (stat (CURRENT_FILE_NAME, &st1) == 0 && S_ISDIR (st1.st_mode))
918 errno = saved_errno; /* FIXME: errno should be read-only */
921 if (maybe_recoverable (CURRENT_FILE_NAME))
924 /* If we're trying to create '.', let it be. */
926 /* FIXME: Strange style... */
928 if (CURRENT_FILE_NAME[name_length] == '.'
930 || CURRENT_FILE_NAME[name_length - 1] == '/'))
933 ERROR ((0, errno, _("%s: Could not create directory"),
941 if (!we_are_root && MODE_WXUSR != (MODE_WXUSR & current_stat.st_mode))
943 current_stat.st_mode |= MODE_WXUSR;
944 WARN ((0, 0, _("Added write and execute permission to directory %s"),
949 /* MSDOS does not associate timestamps with directories. In this
950 case, no need to try delaying their restoration. */
954 /* FIXME: I do not believe in this. Ignoring time stamps does not
955 alleviate the need of delaying the restoration of directories'
956 mode. Let's ponder this for a little while. */
958 set_mode (CURRENT_FILE_NAME, ¤t_stat);
962 data = ((struct delayed_set_stat *)
963 xmalloc (sizeof (struct delayed_set_stat)));
964 data->file_name = xstrdup (CURRENT_FILE_NAME);
965 data->stat_info = current_stat;
966 data->next = delayed_set_stat_head;
967 delayed_set_stat_head = data;
974 fprintf (stdlis, _("Reading %s\n"), current_file_name);
981 case GNUTYPE_MULTIVOL:
983 _("Cannot extract `%s' -- file is continued from another volume"),
985 skip_file (current_stat.st_size);
990 case GNUTYPE_LONGNAME:
991 case GNUTYPE_LONGLINK:
992 ERROR ((0, 0, _("Visible long name error")));
993 skip_file (current_stat.st_size);
1000 _("Unknown file type '%c' for %s, extracted as normal file"),
1001 typeflag, CURRENT_FILE_NAME));
1005 #undef CURRENT_FILE_NAME
1008 /*----------------------------------------------------------------.
1009 | Set back the utime and mode for all the extracted directories. |
1010 `----------------------------------------------------------------*/
1013 apply_delayed_set_stat (void)
1015 struct delayed_set_stat *data;
1017 while (delayed_set_stat_head != NULL)
1019 data = delayed_set_stat_head;
1020 delayed_set_stat_head = delayed_set_stat_head->next;
1021 set_stat (data->file_name, &data->stat_info, 0);
1022 free (data->file_name);