X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fcreate.c;h=ff69876192dcdf8a084d4b017acb5cd64266f6da;hb=b6d3432810ce8b001200e88ea4bd0251a063caf6;hp=793007f146dcb2d3dded06b7cb5b8dc9d502f2d9;hpb=19335cdfb4bd2a246c26f8f36ebbec3f75e7846f;p=chaz%2Ftar diff --git a/src/create.c b/src/create.c index 793007f..ff69876 100644 --- a/src/create.c +++ b/src/create.c @@ -1,7 +1,7 @@ /* Create a tar archive. Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001, - 2003, 2004 Free Software Foundation, Inc. + 2003, 2004, 2005 Free Software Foundation, Inc. Written by John Gilmore, on 1985-08-25. @@ -17,21 +17,12 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., - 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#include "system.h" - -#if HAVE_UTIME_H -# include -#else -struct utimbuf - { - long actime; - long modtime; - }; -#endif +#include #include +#include #include "common.h" #include @@ -51,6 +42,10 @@ struct link ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \ : (uintmax_t) -1) +/* The maximum uintmax_t value that can be represented with octal + digits and a trailing NUL in BUFFER. */ +#define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8) + /* Convert VALUE to an octal representation suitable for tar headers. Output to buffer WHERE with size SIZE. The result is undefined if SIZE is 0 or if VALUE is too large to fit. */ @@ -69,6 +64,29 @@ to_octal (uintmax_t value, char *where, size_t size) while (i); } +/* Copy at most LEN bytes from the string SRC to DST. Terminate with + NUL unless SRC is LEN or more bytes long. */ + +static void +tar_copy_str (char *dst, const char *src, size_t len) +{ + size_t i; + for (i = 0; i < len; i++) + if (! (dst[i] = src[i])) + break; +} + +/* Same as tar_copy_str, but always terminate with NUL if using + is OLDGNU format */ + +static void +tar_name_copy_str (char *dst, const char *src, size_t len) +{ + tar_copy_str (dst, src, len); + if (archive_format == OLDGNU_FORMAT) + dst[len-1] = 0; +} + /* Convert NEGATIVE VALUE to a base-256 representation suitable for tar headers. NEGATIVE is 1 if VALUE was negative before being cast to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE. @@ -325,23 +343,27 @@ uintmax_to_chars (uintmax_t v, char *p, size_t s) } void -string_to_chars (char *str, char *p, size_t s) +string_to_chars (char const *str, char *p, size_t s) { - strncpy (p, str, s); - p[s-1] = 0; + tar_copy_str (p, str, s); + p[s - 1] = '\0'; } -/* A file is not dumpable if +/* A file is considered dumpable if it is sparse and both --sparse and --totals + are specified. + Otherwise, it is dumpable unless any of the following conditions occur: + a) it is empty *and* world-readable, or b) current archive is /dev/null */ bool file_dumpable_p (struct tar_stat_info *st) { - return !(dev_null_output - || (st->archive_file_size == 0 - && (st->stat.st_mode & MODE_R) == MODE_R)); + if (dev_null_output) + return totals_option && sparse_option && sparse_file_p (st); + return !(st->archive_file_size == 0 + && (st->stat.st_mode & MODE_R) == MODE_R); } @@ -361,15 +383,6 @@ write_eot (void) set_next_block_after (pointer); } -/* Copy at most LEN bytes from SRC to DST. Terminate with NUL unless - SRC is LEN characters long */ -static void -tar_copy_str (char *dst, const char *src, size_t len) -{ - dst[len-1] = 0; - strncpy (dst, src, len); -} - /* Write a "private" header */ union block * start_private_header (const char *name, size_t size) @@ -379,7 +392,7 @@ start_private_header (const char *name, size_t size) memset (header->buffer, 0, sizeof (union block)); - tar_copy_str (header->header.name, name, NAME_FIELD_SIZE); + tar_name_copy_str (header->header.name, name, NAME_FIELD_SIZE); OFF_TO_CHARS (size, header->header.size); time (&t); @@ -388,7 +401,7 @@ start_private_header (const char *name, size_t size) UID_TO_CHARS (getuid (), header->header.uid); GID_TO_CHARS (getgid (), header->header.gid); MAJOR_TO_CHARS (0, header->header.devmajor); - MAJOR_TO_CHARS (0, header->header.devminor); + MINOR_TO_CHARS (0, header->header.devminor); strncpy (header->header.magic, TMAGIC, TMAGLEN); strncpy (header->header.version, TVERSION, TVERSLEN); return header; @@ -402,7 +415,7 @@ write_short_name (struct tar_stat_info *st) { union block *header = find_next_block (); memset (header->buffer, 0, sizeof (union block)); - tar_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE); + tar_name_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE); return header; } @@ -410,7 +423,7 @@ write_short_name (struct tar_stat_info *st) memset(field, byte, sizeof(field)-1); \ (field)[sizeof(field)-1] = 0; \ } while (0) - + /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */ static void write_gnu_long_link (struct tar_stat_info *st, const char *p, char type) @@ -419,7 +432,7 @@ write_gnu_long_link (struct tar_stat_info *st, const char *p, char type) size_t bufsize; union block *header; char *tmpname; - + header = start_private_header ("././@LongLink", size); FILL(header->header.mtime, '0'); FILL(header->header.mode, '0'); @@ -433,13 +446,13 @@ write_gnu_long_link (struct tar_stat_info *st, const char *p, char type) gid_to_gname (0, &tmpname); GNAME_TO_CHARS (tmpname, header->header.gname); free (tmpname); - + strcpy (header->header.magic, OLDGNU_MAGIC); header->header.typeflag = type; finish_header (st, header, -1); header = find_next_block (); - + bufsize = available_space_after (header); while (bufsize < size) @@ -563,19 +576,29 @@ write_long_name (struct tar_stat_info *st) return write_short_name (st); } -static union block * -write_extended (struct tar_stat_info *st, union block *old_header) +union block * +write_extended (bool global, struct tar_stat_info *st, union block *old_header) { union block *header, hp; char *p; - + int type; + if (extended_header.buffer || extended_header.stk == NULL) return old_header; xheader_finish (&extended_header); memcpy (hp.buffer, old_header, sizeof (hp)); - p = xheader_xhdr_name (st); - xheader_write (XHDTYPE, p, &extended_header); + if (global) + { + type = XGLTYPE; + p = xheader_ghdr_name (); + } + else + { + type = XHDTYPE; + p = xheader_xhdr_name (st); + } + xheader_write (type, p, &extended_header); free (p); header = find_next_block (); memcpy (header, &hp.buffer, sizeof (hp.buffer)); @@ -590,7 +613,8 @@ write_header_name (struct tar_stat_info *st) xheader_store ("path", st, NULL); return write_short_name (st); } - else if (NAME_FIELD_SIZE < strlen (st->file_name)) + else if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) + < strlen (st->file_name)) return write_long_name (st); else return write_short_name (st); @@ -618,8 +642,9 @@ start_header (struct tar_stat_info *st) if (group_option != (gid_t) -1) st->stat.st_gid = group_option; if (mode_option) - st->stat.st_mode = ((st->stat.st_mode & ~MODE_ALL) - | mode_adjust (st->stat.st_mode, mode_option)); + st->stat.st_mode = + ((st->stat.st_mode & ~MODE_ALL) + | mode_adjust (st->stat.st_mode, mode_option, initial_umask)); /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a) for a few tars and came up with the following interoperability @@ -649,39 +674,74 @@ start_header (struct tar_stat_info *st) else MODE_TO_CHARS (st->stat.st_mode, header->header.mode); - if (st->stat.st_uid > MAXOCTAL7 && archive_format == POSIX_FORMAT) - xheader_store ("uid", st, NULL); - else - UID_TO_CHARS (st->stat.st_uid, header->header.uid); + { + uid_t uid = st->stat.st_uid; + if (archive_format == POSIX_FORMAT + && MAX_OCTAL_VAL (header->header.uid) < uid) + { + xheader_store ("uid", st, NULL); + uid = 0; + } + UID_TO_CHARS (uid, header->header.uid); + } - if (st->stat.st_gid > MAXOCTAL7 && archive_format == POSIX_FORMAT) - xheader_store ("gid", st, NULL); - else - GID_TO_CHARS (st->stat.st_gid, header->header.gid); + { + gid_t gid = st->stat.st_gid; + if (archive_format == POSIX_FORMAT + && MAX_OCTAL_VAL (header->header.gid) < gid) + { + xheader_store ("gid", st, NULL); + gid = 0; + } + GID_TO_CHARS (gid, header->header.gid); + } - if (st->stat.st_size > MAXOCTAL11 && archive_format == POSIX_FORMAT) - xheader_store ("size", st, NULL); - else - OFF_TO_CHARS (st->stat.st_size, header->header.size); + { + off_t size = st->stat.st_size; + if (archive_format == POSIX_FORMAT + && MAX_OCTAL_VAL (header->header.size) < size) + { + xheader_store ("size", st, NULL); + size = 0; + } + OFF_TO_CHARS (size, header->header.size); + } - TIME_TO_CHARS (st->stat.st_mtime, header->header.mtime); + { + struct timespec mtime = st->mtime; + if (archive_format == POSIX_FORMAT) + { + if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec + || mtime.tv_nsec != 0) + xheader_store ("mtime", st, NULL); + if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec) + mtime.tv_sec = 0; + } + TIME_TO_CHARS (mtime.tv_sec, header->header.mtime); + } /* FIXME */ if (S_ISCHR (st->stat.st_mode) || S_ISBLK (st->stat.st_mode)) { - st->devmajor = major (st->stat.st_rdev); - st->devminor = minor (st->stat.st_rdev); + major_t devmajor = major (st->stat.st_rdev); + minor_t devminor = minor (st->stat.st_rdev); - if (st->devmajor > MAXOCTAL7 && archive_format == POSIX_FORMAT) - xheader_store ("devmajor", st, NULL); - else - MAJOR_TO_CHARS (st->devmajor, header->header.devmajor); + if (archive_format == POSIX_FORMAT + && MAX_OCTAL_VAL (header->header.devmajor) < devmajor) + { + xheader_store ("devmajor", st, NULL); + devmajor = 0; + } + MAJOR_TO_CHARS (devmajor, header->header.devmajor); - if (st->devminor > MAXOCTAL7 && archive_format == POSIX_FORMAT) - xheader_store ("devminor", st, NULL); - else - MAJOR_TO_CHARS (st->devminor, header->header.devminor); + if (archive_format == POSIX_FORMAT + && MAX_OCTAL_VAL (header->header.devminor) < devminor) + { + xheader_store ("devminor", st, NULL); + devminor = 0; + } + MINOR_TO_CHARS (devminor, header->header.devminor); } else if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT) { @@ -697,8 +757,8 @@ start_header (struct tar_stat_info *st) else if (incremental_option) if (archive_format == OLDGNU_FORMAT || archive_format == GNU_FORMAT) { - TIME_TO_CHARS (st->stat.st_atime, header->oldgnu_header.atime); - TIME_TO_CHARS (st->stat.st_ctime, header->oldgnu_header.ctime); + TIME_TO_CHARS (st->atime.tv_sec, header->oldgnu_header.atime); + TIME_TO_CHARS (st->ctime.tv_sec, header->oldgnu_header.ctime); } header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE; @@ -737,15 +797,13 @@ start_header (struct tar_stat_info *st) && (strlen (st->uname) > UNAME_FIELD_SIZE || !string_ascii_p (st->uname))) xheader_store ("uname", st, NULL); - else - UNAME_TO_CHARS (st->uname, header->header.uname); + UNAME_TO_CHARS (st->uname, header->header.uname); if (archive_format == POSIX_FORMAT && (strlen (st->gname) > GNAME_FIELD_SIZE || !string_ascii_p (st->gname))) xheader_store ("gname", st, NULL); - else - GNAME_TO_CHARS (st->gname, header->header.gname); + GNAME_TO_CHARS (st->gname, header->header.gname); } return header; @@ -804,7 +862,7 @@ finish_header (struct tar_stat_info *st, print_header (st, block_ordinal); } - header = write_extended (st, header); + header = write_extended (false, st, header); simple_finish_header (header); } @@ -815,7 +873,7 @@ pad_archive (off_t size_left) union block *blk; while (size_left > 0) { - save_sizeleft = size_left; + mv_size_left (size_left); blk = find_next_block (); memset (blk->buffer, 0, BLOCKSIZE); set_next_block_after (blk); @@ -841,16 +899,13 @@ dump_regular_file (int fd, struct tar_stat_info *st) finish_header (st, blk, block_ordinal); + mv_begin (st); while (size_left > 0) { size_t bufsize, count; - if (multi_volume_option) - { - assign_string (&save_name, st->file_name); - save_sizeleft = size_left; - save_totsize = st->stat.st_size; - } + mv_size_left (size_left); + blk = find_next_block (); bufsize = available_space_after (blk); @@ -873,8 +928,8 @@ dump_regular_file (int fd, struct tar_stat_info *st) return dump_status_short; } size_left -= count; - - set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE); + if (count) + set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE); if (count != bufsize) { @@ -888,7 +943,7 @@ dump_regular_file (int fd, struct tar_stat_info *st) STRINGIFY_BIGINT (size_left, buf))); if (! ignore_failed_read_option) exit_status = TAREXIT_FAILURE; - pad_archive (size_left); + pad_archive (size_left - (bufsize-count)); return dump_status_short; } } @@ -896,7 +951,8 @@ dump_regular_file (int fd, struct tar_stat_info *st) } static void -dump_regular_finish (int fd, struct tar_stat_info *st, time_t original_ctime) +dump_regular_finish (int fd, struct tar_stat_info *st, + struct timespec original_ctime) { if (fd >= 0) { @@ -905,7 +961,8 @@ dump_regular_finish (int fd, struct tar_stat_info *st, time_t original_ctime) { stat_diag (st->orig_file_name); } - else if (final_stat.st_ctime != original_ctime) + else if (timespec_cmp (get_stat_ctime (&final_stat), original_ctime) + != 0) { WARN ((0, 0, _("%s: file changed as we read it"), quotearg_colon (st->orig_file_name))); @@ -922,6 +979,47 @@ dump_regular_finish (int fd, struct tar_stat_info *st, time_t original_ctime) } } +/* Look in directory DIRNAME for a cache directory tag file + with the magic name "CACHEDIR.TAG" and a standard header, + as described at: + http://www.brynosaurus.com/cachedir + Applications can write this file into directories they create + for use as caches containing purely regenerable, non-precious data, + allowing us to avoid archiving them if --exclude-caches is specified. */ + +#define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55" +#define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1) + +static bool +check_cache_directory (char *dirname) +{ + static char tagname[] = "CACHEDIR.TAG"; + char *tagpath; + int fd; + int tag_present = false; + + tagpath = xmalloc (strlen (dirname) + strlen (tagname) + 1); + strcpy (tagpath, dirname); + strcat (tagpath, tagname); + + fd = open (tagpath, O_RDONLY); + if (fd >= 0) + { + static char tagbuf[CACHEDIR_SIGNATURE_SIZE]; + + if (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE) + == CACHEDIR_SIGNATURE_SIZE + && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0) + tag_present = true; + + close (fd); + } + + free (tagpath); + + return tag_present; +} + static void dump_dir0 (char *directory, struct tar_stat_info *st, int top_level, dev_t parent_device) @@ -938,7 +1036,7 @@ dump_dir0 (char *directory, if (!blk) return; - if (incremental_option) + if (incremental_option && archive_format != POSIX_FORMAT) blk->header.typeflag = GNUTYPE_DUMPDIR; else /* if (standard_option) */ blk->header.typeflag = DIRTYPE; @@ -949,51 +1047,51 @@ dump_dir0 (char *directory, finish_header (st, blk, block_ordinal); else if (gnu_list_name->dir_contents) { - off_t size_left; - off_t totsize; - size_t bufsize; - ssize_t count; - const char *buffer, *p_buffer; - - block_ordinal = current_block_ordinal (); - buffer = gnu_list_name->dir_contents; /* FOO */ - totsize = 0; - if (buffer) - for (p_buffer = buffer; *p_buffer; ) - { - size_t size = strlen (p_buffer) + 1; - totsize += size; - p_buffer += size; - } - totsize++; - OFF_TO_CHARS (totsize, blk->header.size); - finish_header (st, blk, block_ordinal); - p_buffer = buffer; - size_left = totsize; - while (size_left > 0) + if (archive_format == POSIX_FORMAT) { - if (multi_volume_option) - { - assign_string (&save_name, st->orig_file_name); - save_sizeleft = size_left; - save_totsize = totsize; - } - blk = find_next_block (); - bufsize = available_space_after (blk); - if (size_left < bufsize) + xheader_store ("GNU.dumpdir", st, gnu_list_name->dir_contents); + finish_header (st, blk, block_ordinal); + } + else + { + off_t size_left; + off_t totsize; + size_t bufsize; + ssize_t count; + const char *buffer, *p_buffer; + + block_ordinal = current_block_ordinal (); + buffer = gnu_list_name->dir_contents; + if (buffer) + totsize = dumpdir_size (buffer); + else + totsize = 0; + OFF_TO_CHARS (totsize, blk->header.size); + finish_header (st, blk, block_ordinal); + p_buffer = buffer; + size_left = totsize; + + mv_begin (st); + mv_total_size (totsize); + while (size_left > 0) { - bufsize = size_left; - count = bufsize % BLOCKSIZE; - if (count) - memset (blk->buffer + size_left, 0, BLOCKSIZE - count); + mv_size_left (size_left); + blk = find_next_block (); + bufsize = available_space_after (blk); + if (size_left < bufsize) + { + bufsize = size_left; + count = bufsize % BLOCKSIZE; + if (count) + memset (blk->buffer + size_left, 0, BLOCKSIZE - count); + } + memcpy (blk->buffer, p_buffer, bufsize); + size_left -= bufsize; + p_buffer += bufsize; + set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE); } - memcpy (blk->buffer, p_buffer, bufsize); - size_left -= bufsize; - p_buffer += bufsize; - set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE); + mv_end (); } - if (multi_volume_option) - assign_string (&save_name, 0); return; } } @@ -1012,10 +1110,20 @@ dump_dir0 (char *directory, return; } + if (exclude_caches_option + && check_cache_directory(st->orig_file_name)) + { + if (verbose_option) + WARN ((0, 0, + _("%s: contains a cache directory tag; not dumped"), + quotearg_colon (st->orig_file_name))); + return; + } + { char const *entry; size_t entry_len; - char *name_buf = strdup (st->orig_file_name); + char *name_buf = xstrdup (st->orig_file_name); size_t name_size = strlen (name_buf); size_t name_len = name_size; @@ -1147,8 +1255,8 @@ create_archive (void) /* Calculate the hash of a link. */ -static unsigned -hash_link (void const *entry, unsigned n_buckets) +static size_t +hash_link (void const *entry, size_t n_buckets) { struct link const *l = entry; uintmax_t num = l->dev ^ l->ino; @@ -1199,13 +1307,15 @@ dump_hard_link (struct tar_stat_info *st) if ((duplicate = hash_lookup (link_table, &lp))) { /* We found a link. */ - char const *link_name = safer_name_suffix (duplicate->name, true); + char const *link_name = safer_name_suffix (duplicate->name, true, + absolute_names_option); duplicate->nlink--; block_ordinal = current_block_ordinal (); assign_string (&st->link_name, link_name); - if (NAME_FIELD_SIZE < strlen (link_name)) + if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) + < strlen (link_name)) write_long_link (st); st->stat.st_size = 0; @@ -1266,7 +1376,7 @@ check_links (void) { if (lp->nlink) { - WARN ((0, 0, _("Missing links to '%s'.\n"), lp->name)); + WARN ((0, 0, _("Missing links to %s.\n"), quote (lp->name))); } } } @@ -1287,15 +1397,16 @@ dump_file0 (struct tar_stat_info *st, char *p, { union block *header; char type; - time_t original_ctime; - struct utimbuf restore_times; + struct timespec original_ctime; + struct timespec restore_times[2]; off_t block_ordinal = -1; if (interactive_option && !confirm ("add", p)) return; assign_string (&st->orig_file_name, p); - assign_string (&st->file_name, safer_name_suffix (p, false)); + assign_string (&st->file_name, + safer_name_suffix (p, false, absolute_names_option)); if (deref_stat (dereference_option, p, &st->stat) != 0) { @@ -1303,10 +1414,9 @@ dump_file0 (struct tar_stat_info *st, char *p, return; } st->archive_file_size = st->stat.st_size; - sys_stat_nanoseconds (st); - original_ctime = st->stat.st_ctime; - restore_times.actime = st->stat.st_atime; - restore_times.modtime = st->stat.st_mtime; + st->atime = restore_times[0] = get_stat_atime (&st->stat); + st->mtime = restore_times[1] = get_stat_mtime (&st->stat); + st->ctime = original_ctime = get_stat_ctime (&st->stat); #ifdef S_ISHIDDEN if (S_ISHIDDEN (st->stat.st_mode)) @@ -1329,10 +1439,10 @@ dump_file0 (struct tar_stat_info *st, char *p, if (!(incremental_option && !is_individual_file (p)) && !S_ISDIR (st->stat.st_mode) - && OLDER_STAT_TIME (st->stat, m) - && (!after_date_option || OLDER_STAT_TIME (st->stat, c))) + && OLDER_TAR_STAT_TIME (*st, m) + && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c))) { - if (!incremental_option) + if (!incremental_option && verbose_option) WARN ((0, 0, _("%s: file is unchanged; not dumped"), quotearg_colon (p))); return; @@ -1346,15 +1456,15 @@ dump_file0 (struct tar_stat_info *st, char *p, return; } + if (is_avoided_name (p)) + return; if (S_ISDIR (st->stat.st_mode)) { dump_dir (st, top_level, parent_device); if (atime_preserve_option) - utime (p, &restore_times); + utimens (p, restore_times); return; } - else if (is_avoided_name (p)) - return; else { /* Check for multiple links. */ @@ -1386,7 +1496,7 @@ dump_file0 (struct tar_stat_info *st, char *p, else fd = -1; - if (sparse_option && sparse_file_p (st)) + if (fd != -1 && sparse_option && sparse_file_p (st)) { status = sparse_dump_file (fd, st); if (status == dump_status_not_implemented) @@ -1398,14 +1508,12 @@ dump_file0 (struct tar_stat_info *st, char *p, switch (status) { case dump_status_ok: - if (multi_volume_option) - assign_string (&save_name, 0); + mv_end (); dump_regular_finish (fd, st, original_ctime); break; case dump_status_short: - if (multi_volume_option) - assign_string (&save_name, 0); + mv_end (); close (fd); break; @@ -1418,7 +1526,7 @@ dump_file0 (struct tar_stat_info *st, char *p, } if (atime_preserve_option) - utime (st->orig_file_name, &restore_times); + utimens (st->orig_file_name, restore_times); file_count_links (st); return; } @@ -1439,7 +1547,7 @@ dump_file0 (struct tar_stat_info *st, char *p, } buffer[size] = '\0'; assign_string (&st->link_name, buffer); - if (size > NAME_FIELD_SIZE) + if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) < size) write_long_link (st); block_ordinal = current_block_ordinal (); @@ -1519,5 +1627,7 @@ dump_file (char *p, int top_level, dev_t parent_device) struct tar_stat_info st; tar_stat_init (&st); dump_file0 (&st, p, top_level, parent_device); + if (listed_incremental_option) + update_parent_directory (p); tar_stat_destroy (&st); }