X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fextract.c;h=80f2f9ceec68d1616d311680c6537e30cb83b348;hb=2f800ce3fb9c38360e1b6dac70ee0d8ceae72c6a;hp=d193807421913e8db12dab2a4fc1f2c9edd8bf0b;hpb=120e96c480fbfc5fa31fba0f59ba1a45953b838e;p=chaz%2Ftar diff --git a/src/extract.c b/src/extract.c index d193807..80f2f9c 100644 --- a/src/extract.c +++ b/src/extract.c @@ -1,7 +1,7 @@ /* Extract files from a tar archive. Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000, - 2001, 2003, 2004 Free Software Foundation, Inc. + 2001, 2003, 2004, 2005 Free Software Foundation, Inc. Written by John Gilmore, on 1985-11-19. @@ -21,22 +21,13 @@ #include #include +#include #include #include -#if HAVE_UTIME_H -# include -#else -struct utimbuf - { - long actime; - long modtime; - }; -#endif - #include "common.h" -bool we_are_root; /* true if our effective uid == 0 */ +static bool we_are_root; /* true if our effective uid == 0 */ static mode_t newdir_umask; /* umask when creating new directories */ static mode_t current_umask; /* current umask (which is set to 0 if -p) */ @@ -57,8 +48,8 @@ enum permstatus /* List of directories whose statuses we need to extract after we've finished extracting their subsidiary files. If you consider each contiguous subsequence of elements of the form [D]?[^D]*, where [D] - represents an element where AFTER_SYMLINKS is nonzero and [^D] - represents an element where AFTER_SYMLINKS is zero, then the head + represents an element where AFTER_LINKS is nonzero and [^D] + represents an element where AFTER_LINKS is zero, then the head of the subsequence has the longest name, and each non-head element in the prefix is an ancestor (in the directory hierarchy) of the preceding element. */ @@ -70,28 +61,31 @@ struct delayed_set_stat size_t file_name_len; mode_t invert_permissions; enum permstatus permstatus; - bool after_symlinks; + bool after_links; char file_name[1]; }; static struct delayed_set_stat *delayed_set_stat_head; -/* List of symbolic links whose creation we have delayed. */ -struct delayed_symlink +/* List of links whose creation we have delayed. */ +struct delayed_link { - /* The next delayed symbolic link in the list. */ - struct delayed_symlink *next; + /* The next delayed link in the list. */ + struct delayed_link *next; /* The device, inode number and last-modified time of the placeholder. */ dev_t dev; ino_t ino; time_t mtime; - /* The desired owner and group of the symbolic link. */ + /* True if the link is symbolic. */ + bool is_symlink; + + /* The desired owner and group of the link, if it is a symlink. */ uid_t uid; gid_t gid; - /* A list of sources for this symlink. The sources are all to be + /* A list of sources for this link. The sources are all to be hard-linked together. */ struct string_list *sources; @@ -99,7 +93,7 @@ struct delayed_symlink char target[1]; }; -static struct delayed_symlink *delayed_symlink_head; +static struct delayed_link *delayed_link_head; struct string_list { @@ -119,7 +113,7 @@ extr_init (void) FIXME: Should the same be done after handling -C option ? */ if (one_file_system_option) { - struct stat st; + struct stat st; char *dir = xgetcwd (); if (deref_stat (true, dir, &st)) @@ -127,7 +121,7 @@ extr_init (void) else root_device = st.st_dev; } - + /* Option -p clears the kernel umask, so it does not affect proper restoration of file permissions. New intermediate directories will comply with umask at start of program. */ @@ -201,15 +195,30 @@ set_mode (char const *file_name, /* Check time after successfully setting FILE_NAME's time stamp to T. */ static void -check_time (char const *file_name, time_t t) +check_time (char const *file_name, struct timespec t) { - time_t now; - if (t <= 0) + if (t.tv_sec <= 0) WARN ((0, 0, _("%s: implausibly old time stamp %s"), - file_name, tartime (t))); - else if (start_time < t && (now = time (0)) < t) - WARN ((0, 0, _("%s: time stamp %s is %lu s in the future"), - file_name, tartime (t), (unsigned long) (t - now))); + file_name, tartime (t, true))); + else if (timespec_cmp (start_time, t) < 0) + { + struct timespec now; + gettime (&now); + if (timespec_cmp (now, t) < 0) + { + unsigned long int ds = t.tv_sec - now.tv_sec; + int dns = t.tv_nsec - now.tv_nsec; + char dnsbuf[sizeof ".FFFFFFFFF"]; + if (dns < 0) + { + dns += 1000000000; + ds--; + } + code_ns_fraction (dns, dnsbuf); + WARN ((0, 0, _("%s: time stamp %s is %lu%s s in the future"), + file_name, tartime (t, true), ds, dnsbuf)); + } + } } /* Restore stat attributes (owner, group, mode and times) for @@ -233,8 +242,6 @@ set_stat (char const *file_name, mode_t invert_permissions, enum permstatus permstatus, char typeflag) { - struct utimbuf utimbuf; - if (typeflag != SYMTYPE) { /* We do the utime before the chmod because some versions of utime are @@ -248,19 +255,16 @@ set_stat (char const *file_name, /* FIXME: incremental_option should set ctime too, but how? */ - if (incremental_option) - utimbuf.actime = stat_info->st_atime; - else - utimbuf.actime = start_time; - - utimbuf.modtime = stat_info->st_mtime; + struct timespec ts[2]; + ts[0] = incremental_option ? get_stat_atime (stat_info) : start_time; + ts[1] = get_stat_mtime (stat_info); - if (utime (file_name, &utimbuf) < 0) + if (utimens (file_name, ts) != 0) utime_error (file_name); else { - check_time (file_name, utimbuf.actime); - check_time (file_name, utimbuf.modtime); + check_time (file_name, ts[0]); + check_time (file_name, ts[1]); } } @@ -321,7 +325,7 @@ delay_set_stat (char const *file_name, struct stat const *stat_info, strcpy (data->file_name, file_name); data->invert_permissions = invert_permissions; data->permstatus = permstatus; - data->after_symlinks = 0; + data->after_links = 0; data->stat_info = *stat_info; data->next = delayed_set_stat_head; delayed_set_stat_head = data; @@ -360,7 +364,7 @@ repair_delayed_set_stat (char const *dir, quotearg_colon (dir))); } -/* After a file/link/symlink/directory creation has failed, see if +/* After a file/link/directory creation has failed, see if it's because some required directory was not present, and if so, create all required directories. Return non-zero if a directory was created. */ @@ -512,12 +516,12 @@ maybe_recoverable (char *file_name, int *interdir_made) } /* Fix the statuses of all directories whose statuses need fixing, and - which are not ancestors of FILE_NAME. If AFTER_SYMLINKS is + which are not ancestors of FILE_NAME. If AFTER_LINKS is nonzero, do this for all such directories; otherwise, stop at the first directory that is marked to be fixed up only after delayed - symlinks are applied. */ + links are applied. */ static void -apply_nonancestor_delayed_set_stat (char const *file_name, bool after_symlinks) +apply_nonancestor_delayed_set_stat (char const *file_name, bool after_links) { size_t file_name_len = strlen (file_name); bool check_for_renamed_directories = 0; @@ -529,9 +533,9 @@ apply_nonancestor_delayed_set_stat (char const *file_name, bool after_symlinks) struct stat st; struct stat const *cur_info = 0; - check_for_renamed_directories |= data->after_symlinks; + check_for_renamed_directories |= data->after_links; - if (after_symlinks < data->after_symlinks + if (after_links < data->after_links || (data->file_name_len < file_name_len && file_name[data->file_name_len] && (ISSLASH (file_name[data->file_name_len]) @@ -576,7 +580,7 @@ extract_dir (char *file_name, int typeflag) int status; mode_t mode; int interdir_made = 0; - + if (incremental_option) /* Read the entry and delete files that aren't listed in the archive. */ purge_directory (file_name); @@ -608,10 +612,10 @@ extract_dir (char *file_name, int typeflag) } errno = EEXIST; } - + if (maybe_recoverable (file_name, &interdir_made)) continue; - + if (errno != EEXIST) { mkdir_error (file_name); @@ -619,7 +623,7 @@ extract_dir (char *file_name, int typeflag) } break; } - + if (status == 0 || old_files_option == DEFAULT_OLD_FILES || old_files_option == OVERWRITE_OLD_FILES) @@ -666,7 +670,7 @@ open_output_file (char *file_name, int typeflag) fd = open (file_name, openflag, mode); #endif /* not O_CTG */ - + return fd; } @@ -680,7 +684,7 @@ extract_file (char *file_name, int typeflag) size_t count; size_t written; int interdir_made = 0; - + /* FIXME: deal with protection issues. */ if (to_stdout_option) @@ -699,14 +703,14 @@ extract_file (char *file_name, int typeflag) do fd = open_output_file (file_name, typeflag); while (fd < 0 && maybe_recoverable (file_name, &interdir_made)); - + if (fd < 0) { open_error (file_name); return 1; } } - + if (current_stat_info.is_sparse) sparse_extract_file (fd, ¤t_stat_info, &size); else @@ -722,7 +726,7 @@ extract_file (char *file_name, int typeflag) /* Locate data, determine max length writeable, write it, block that we have used the data, then check if the write worked. */ - + data_block = find_next_block (); if (! data_block) { @@ -731,13 +735,13 @@ extract_file (char *file_name, int typeflag) } written = available_space_after (data_block); - + if (written > size) written = size; errno = 0; count = full_write (fd, data_block->buffer, written); size -= written; - + set_next_block_after ((union block *) (data_block->buffer + written - 1)); if (count != written) @@ -748,7 +752,7 @@ extract_file (char *file_name, int typeflag) break; } } - + skip_file (size); if (multi_volume_option) @@ -773,14 +777,94 @@ extract_file (char *file_name, int typeflag) typeflag); return status; -} +} + +/* Create a placeholder file with name FILE_NAME, which will be + replaced after other extraction is done by a symbolic link if + IS_SYMLINK is true, and by a hard link otherwise. Set + *INTERDIR_MADE if an intermediate directory is made in the + process. */ + +static int +create_placeholder_file (char *file_name, bool is_symlink, int *interdir_made) +{ + int fd; + struct stat st; + + while ((fd = open (file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0) + if (! maybe_recoverable (file_name, interdir_made)) + break; + + if (fd < 0) + open_error (file_name); + else if (fstat (fd, &st) != 0) + { + stat_error (file_name); + close (fd); + } + else if (close (fd) != 0) + close_error (file_name); + else + { + struct delayed_set_stat *h; + struct delayed_link *p = + xmalloc (offsetof (struct delayed_link, target) + + strlen (current_stat_info.link_name) + + 1); + p->next = delayed_link_head; + delayed_link_head = p; + p->dev = st.st_dev; + p->ino = st.st_ino; + p->mtime = st.st_mtime; + p->is_symlink = is_symlink; + if (is_symlink) + { + p->uid = current_stat_info.stat.st_uid; + p->gid = current_stat_info.stat.st_gid; + } + p->sources = xmalloc (offsetof (struct string_list, string) + + strlen (file_name) + 1); + p->sources->next = 0; + strcpy (p->sources->string, file_name); + strcpy (p->target, current_stat_info.link_name); + + h = delayed_set_stat_head; + if (h && ! h->after_links + && strncmp (file_name, h->file_name, h->file_name_len) == 0 + && ISSLASH (file_name[h->file_name_len]) + && (base_name (file_name) == file_name + h->file_name_len + 1)) + { + do + { + h->after_links = 1; + + if (stat (h->file_name, &st) != 0) + stat_error (h->file_name); + else + { + h->stat_info.st_dev = st.st_dev; + h->stat_info.st_ino = st.st_ino; + } + } + while ((h = h->next) && ! h->after_links); + } + + return 0; + } + + return -1; +} static int extract_link (char *file_name, int typeflag) { - char const *link_name = safer_name_suffix (current_stat_info.link_name, true); + char const *link_name = safer_name_suffix (current_stat_info.link_name, + true, absolute_names_option); int interdir_made = 0; - + + if (! absolute_names_option && contains_dot_dot (link_name)) + return create_placeholder_file (file_name, false, &interdir_made); + do { struct stat st1, st2; @@ -790,7 +874,7 @@ extract_link (char *file_name, int typeflag) if (status == 0) { - struct delayed_symlink *ds = delayed_symlink_head; + struct delayed_link *ds = delayed_link_head; if (ds && lstat (link_name, &st1) == 0) for (; ds; ds = ds->next) if (ds->dev == st1.st_dev @@ -812,7 +896,7 @@ extract_link (char *file_name, int typeflag) && st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)) return 0; - + errno = e; } while (maybe_recoverable (file_name, &interdir_made)); @@ -823,93 +907,28 @@ extract_link (char *file_name, int typeflag) return 1; } return 0; -} +} static int extract_symlink (char *file_name, int typeflag) { #ifdef HAVE_SYMLINK - int status, fd; + int status; int interdir_made = 0; - - if (absolute_names_option - || ! (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name) - || contains_dot_dot (current_stat_info.link_name))) - { - while ((status = symlink (current_stat_info.link_name, file_name))) - if (!maybe_recoverable (file_name, &interdir_made)) - break; - if (status == 0) - set_stat (file_name, ¤t_stat_info.stat, 0, 0, 0, SYMTYPE); - else - symlink_error (current_stat_info.link_name, file_name); - } - else - { - /* This symbolic link is potentially dangerous. Don't - create it now; instead, create a placeholder file, which - will be replaced after other extraction is done. */ - struct stat st; + if (! absolute_names_option + && (IS_ABSOLUTE_FILE_NAME (current_stat_info.link_name) + || contains_dot_dot (current_stat_info.link_name))) + return create_placeholder_file (file_name, true, &interdir_made); - while ((fd = open (file_name, O_WRONLY | O_CREAT | O_EXCL, 0)) < 0) - if (! maybe_recoverable (file_name, &interdir_made)) - break; - - status = -1; - if (fd < 0) - open_error (file_name); - else if (fstat (fd, &st) != 0) - { - stat_error (file_name); - close (fd); - } - else if (close (fd) != 0) - close_error (file_name); - else - { - struct delayed_set_stat *h; - struct delayed_symlink *p = xmalloc (offsetof (struct delayed_symlink, target) - + strlen (current_stat_info.link_name) - + 1); - p->next = delayed_symlink_head; - delayed_symlink_head = p; - p->dev = st.st_dev; - p->ino = st.st_ino; - p->mtime = st.st_mtime; - p->uid = current_stat_info.stat.st_uid; - p->gid = current_stat_info.stat.st_gid; - p->sources = xmalloc (offsetof (struct string_list, string) - + strlen (file_name) + 1); - p->sources->next = 0; - strcpy (p->sources->string, file_name); - strcpy (p->target, current_stat_info.link_name); - - h = delayed_set_stat_head; - if (h && ! h->after_symlinks - && strncmp (file_name, h->file_name, h->file_name_len) == 0 - && ISSLASH (file_name[h->file_name_len]) - && (base_name (file_name) == file_name + h->file_name_len + 1)) - { - do - { - h->after_symlinks = 1; - - if (stat (h->file_name, &st) != 0) - stat_error (h->file_name); - else - { - h->stat_info.st_dev = st.st_dev; - h->stat_info.st_ino = st.st_ino; - } - } - while ((h = h->next) && ! h->after_symlinks); - } - - status = 0; - } - } + while ((status = symlink (current_stat_info.link_name, file_name))) + if (!maybe_recoverable (file_name, &interdir_made)) + break; + if (status == 0) + set_stat (file_name, ¤t_stat_info.stat, 0, 0, 0, SYMTYPE); + else + symlink_error (current_stat_info.link_name, file_name); return status; #else @@ -920,9 +939,9 @@ extract_symlink (char *file_name, int typeflag) warned_once = 1; WARN ((0, 0, _("Attempting extraction of symbolic links as hard links"))); } - return extract_link (file_name, typeflag); + return extract_link (file_name, typeflag); #endif -} +} #if S_IFCHR || S_IFBLK static int @@ -930,12 +949,12 @@ extract_node (char *file_name, int typeflag) { int status; int interdir_made = 0; - + do status = mknod (file_name, current_stat_info.stat.st_mode, current_stat_info.stat.st_rdev); while (status && maybe_recoverable (file_name, &interdir_made)); - + if (status != 0) mknod_error (file_name); else @@ -950,7 +969,7 @@ extract_fifo (char *file_name, int typeflag) { int status; int interdir_made = 0; - + while ((status = mkfifo (file_name, current_stat_info.stat.st_mode))) if (!maybe_recoverable (file_name, &interdir_made)) break; @@ -961,7 +980,7 @@ extract_fifo (char *file_name, int typeflag) else mkfifo_error (file_name); return status; -} +} #endif static int @@ -971,7 +990,7 @@ extract_mangle_wrapper (char *file_name, int typeflag) return 0; } - + static int extract_failure (char *file_name, int typeflag) { @@ -989,7 +1008,7 @@ static int prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun) { int rc = 1; - + if (EXTRACT_OVER_PIPE) rc = 0; @@ -1000,7 +1019,7 @@ prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun) *fun = extract_file; rc = 1; break; - + case AREGTYPE: case REGTYPE: case CONTTYPE: @@ -1081,12 +1100,12 @@ prepare_to_extract (char const *file_name, int typeflag, tar_extractor_t *fun) /* Determine whether the extraction should proceed */ if (rc == 0) return 0; - + switch (old_files_option) { case UNLINK_FIRST_OLD_FILES: - if (!remove_any_file (file_name, - recursive_unlink_option ? RECURSIVE_REMOVE_OPTION + if (!remove_any_file (file_name, + recursive_unlink_option ? RECURSIVE_REMOVE_OPTION : ORDINARY_REMOVE_OPTION) && errno && errno != ENOENT) { @@ -1118,7 +1137,7 @@ extract_archive (void) char typeflag; char *file_name; tar_extractor_t fun; - + set_next_block_after (current_header); decode_header (current_header, ¤t_stat_info, ¤t_format, 1); @@ -1133,7 +1152,8 @@ extract_archive (void) if (verbose_option) print_header (¤t_stat_info, -1); - file_name = safer_name_suffix (current_stat_info.file_name, false); + file_name = safer_name_suffix (current_stat_info.file_name, + false, absolute_names_option); if (strip_name_components) { size_t prefix_len = stripped_prefix_len (file_name, strip_name_components); @@ -1172,16 +1192,16 @@ extract_archive (void) } else skip_member (); - + } /* Extract the symbolic links whose final extraction were delayed. */ static void -apply_delayed_symlinks (void) +apply_delayed_links (void) { - struct delayed_symlink *ds; + struct delayed_link *ds; - for (ds = delayed_symlink_head; ds; ) + for (ds = delayed_link_head; ds; ) { struct string_list *sources = ds->sources; char const *valid_source = 0; @@ -1192,7 +1212,7 @@ apply_delayed_symlinks (void) struct stat st; /* Make sure the placeholder file is still there. If not, - don't create a symlink, as the placeholder was probably + don't create a link, as the placeholder was probably removed by a later extraction. */ if (lstat (source, &st) == 0 && st.st_dev == ds->dev @@ -1205,6 +1225,11 @@ apply_delayed_symlinks (void) unlink_error (source); else if (valid_source && link (valid_source, source) == 0) ; + else if (!ds->is_symlink) + { + if (link (ds->target, source) != 0) + link_error (ds->target, source); + } else if (symlink (ds->target, source) != 0) symlink_error (ds->target, source); else @@ -1225,13 +1250,13 @@ apply_delayed_symlinks (void) } { - struct delayed_symlink *next = ds->next; + struct delayed_link *next = ds->next; free (ds); ds = next; } } - delayed_symlink_head = 0; + delayed_link_head = 0; } /* Finish the extraction of an archive. */ @@ -1241,12 +1266,12 @@ extract_finish (void) /* First, fix the status of ordinary directories that need fixing. */ apply_nonancestor_delayed_set_stat ("", 0); - /* Then, apply delayed symlinks, so that they don't affect delayed + /* Then, apply delayed links, so that they don't affect delayed directory status-setting for ordinary directories. */ - apply_delayed_symlinks (); + apply_delayed_links (); /* Finally, fix the status of directories that are ancestors - of delayed symlinks. */ + of delayed links. */ apply_nonancestor_delayed_set_stat ("", 1); }