X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Flist.c;h=ac7c8fb209395fcebe346fcbcbc0b11c50cac51e;hb=fc61c174100019859fc3ae930a18839cd316be6e;hp=0c3e223a03e8b19c3485f8f41734cf88bf2f6509;hpb=52429bb9563d5b4bfece4cf9036ce9363e05996b;p=chaz%2Ftar diff --git a/src/list.c b/src/list.c index 0c3e223..ac7c8fb 100644 --- a/src/list.c +++ b/src/list.c @@ -1,13 +1,13 @@ /* List a tar archive, with support routines for reading a tar archive. Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1998, 1999, 2000, - 2001, 2003, 2004, 2005 Free Software Foundation, Inc. + 2001, 2003, 2004, 2005, 2006, 2007, 2010 Free Software Foundation, Inc. Written by John Gilmore, on 1985-08-26. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the - Free Software Foundation; either version 2, or (at your option) any later + Free Software Foundation; either version 3, or (at your option) any later version. This program is distributed in the hope that it will be useful, but @@ -33,6 +33,7 @@ union block *recent_long_name; /* recent long name header and contents */ union block *recent_long_link; /* likewise, for long link */ size_t recent_long_name_blocks; /* number of blocks in recent_long_name */ size_t recent_long_link_blocks; /* likewise, for long link */ +union block *recent_global_header; /* Recent global header block */ static uintmax_t from_header (const char *, size_t, const char *, uintmax_t, uintmax_t, bool, bool); @@ -76,9 +77,9 @@ read_and (void (*do_something) (void)) { prev_status = status; tar_stat_destroy (¤t_stat_info); - xheader_destroy (&extended_header); - status = read_header (false); + status = read_header (¤t_header, ¤t_stat_info, + read_header_auto); switch (status) { case HEADER_STILL_UNREAD: @@ -107,7 +108,6 @@ read_and (void (*do_something) (void)) { case GNUTYPE_VOLHDR: case GNUTYPE_MULTIVOL: - case GNUTYPE_NAMES: break; case DIRTYPE: @@ -140,11 +140,13 @@ read_and (void (*do_something) (void)) { char buf[UINTMAX_STRSIZE_BOUND]; - status = read_header (false); + status = read_header (¤t_header, ¤t_stat_info, + read_header_auto); if (status == HEADER_ZERO_BLOCK) break; - WARN ((0, 0, _("A lone zero block at %s"), - STRINGIFY_BIGINT (current_block_ordinal (), buf))); + WARNOPT (WARN_ALONE_ZERO_BLOCK, + (0, 0, _("A lone zero block at %s"), + STRINGIFY_BIGINT (current_block_ordinal (), buf))); break; } status = prev_status; @@ -206,27 +208,24 @@ void list_archive (void) { off_t block_ordinal = current_block_ordinal (); - /* Print the header block. */ + /* Print the header block. */ + decode_header (current_header, ¤t_stat_info, ¤t_format, 0); if (verbose_option) - print_header (¤t_stat_info, block_ordinal); - + print_header (¤t_stat_info, current_header, block_ordinal); + if (incremental_option) { if (verbose_option > 2) { - if (current_stat_info.dumpdir) + if (is_dumpdir (¤t_stat_info)) list_dumpdir (current_stat_info.dumpdir, dumpdir_size (current_stat_info.dumpdir)); } } - mv_begin (¤t_stat_info); - skip_member (); - - mv_end (); } /* Check header checksum */ @@ -285,20 +284,29 @@ tar_checksum (union block *header, bool silent) } /* Read a block that's supposed to be a header block. Return its - address in "current_header", and if it is good, the file's size in - current_stat_info.stat.st_size. + address in *RETURN_BLOCK, and if it is good, the file's size + and names (file name, link name) in *INFO. + + Return one of enum read_header describing the status of the + operation. - Return 1 for success, 0 if the checksum is bad, EOF on eof, 2 for a - block full of zeros (EOF marker). + The MODE parameter instructs read_header what to do with special + header blocks, i.e.: extended POSIX, GNU long name or long link, + etc.: - If RAW_EXTENDED_HEADERS is nonzero, do not automagically fold the - GNU long name and link headers into later headers. + read_header_auto process them automatically, + read_header_x_raw when a special header is read, return + HEADER_SUCCESS_EXTENDED without actually + processing the header, + read_header_x_global when a POSIX global header is read, + decode it and return HEADER_SUCCESS_EXTENDED. - You must always set_next_block_after(current_header) to skip past + You must always set_next_block_after(*return_block) to skip past the header which this routine reads. */ enum read_header -read_header (bool raw_extended_headers) +read_header (union block **return_block, struct tar_stat_info *info, + enum read_header_mode mode) { union block *header; union block *header_copy; @@ -307,15 +315,15 @@ read_header (bool raw_extended_headers) size_t size, written; union block *next_long_name = 0; union block *next_long_link = 0; - size_t next_long_name_blocks; - size_t next_long_link_blocks; + size_t next_long_name_blocks = 0; + size_t next_long_link_blocks = 0; while (1) { enum read_header status; header = find_next_block (); - current_header = header; + *return_block = header; if (!header) return HEADER_END_OF_FILE; @@ -325,9 +333,9 @@ read_header (bool raw_extended_headers) /* Good block. Decode file size and return. */ if (header->header.typeflag == LNKTYPE) - current_stat_info.stat.st_size = 0; /* links 0 size on tape */ + info->stat.st_size = 0; /* links 0 size on tape */ else - current_stat_info.stat.st_size = OFF_FROM_HEADER (header->header.size); + info->stat.st_size = OFF_FROM_HEADER (header->header.size); if (header->header.typeflag == GNUTYPE_LONGNAME || header->header.typeflag == GNUTYPE_LONGLINK @@ -335,19 +343,18 @@ read_header (bool raw_extended_headers) || header->header.typeflag == XGLTYPE || header->header.typeflag == SOLARIS_XHDTYPE) { - if (raw_extended_headers) + if (mode == read_header_x_raw) return HEADER_SUCCESS_EXTENDED; else if (header->header.typeflag == GNUTYPE_LONGNAME || header->header.typeflag == GNUTYPE_LONGLINK) { - size_t name_size = current_stat_info.stat.st_size; + size_t name_size = info->stat.st_size; size_t n = name_size % BLOCKSIZE; size = name_size + BLOCKSIZE; if (n) size += BLOCKSIZE - n; - if (name_size != current_stat_info.stat.st_size - || size < name_size) + if (name_size != info->stat.st_size || size < name_size) xalloc_die (); header_copy = xmalloc (size + 1); @@ -393,12 +400,23 @@ read_header (bool raw_extended_headers) } else if (header->header.typeflag == XHDTYPE || header->header.typeflag == SOLARIS_XHDTYPE) - xheader_read (header, OFF_FROM_HEADER (header->header.size)); + xheader_read (&info->xhdr, header, + OFF_FROM_HEADER (header->header.size)); else if (header->header.typeflag == XGLTYPE) { - xheader_read (header, OFF_FROM_HEADER (header->header.size)); - xheader_decode_global (); - xheader_destroy (&extended_header); + struct xheader xhdr; + + if (!recent_global_header) + recent_global_header = xmalloc (sizeof *recent_global_header); + memcpy (recent_global_header, header, + sizeof *recent_global_header); + memset (&xhdr, 0, sizeof xhdr); + xheader_read (&xhdr, header, + OFF_FROM_HEADER (header->header.size)); + xheader_decode_global (&xhdr); + xheader_destroy (&xhdr); + if (mode == read_header_x_global) + return HEADER_SUCCESS_EXTENDED; } /* Loop! */ @@ -407,7 +425,7 @@ read_header (bool raw_extended_headers) else { char const *name; - struct posix_header const *h = ¤t_header->header; + struct posix_header const *h = &header->header; char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1]; if (recent_long_name) @@ -438,9 +456,9 @@ read_header (bool raw_extended_headers) recent_long_name = 0; recent_long_name_blocks = 0; } - assign_string (¤t_stat_info.orig_file_name, name); - assign_string (¤t_stat_info.file_name, name); - current_stat_info.had_trailing_slash = strip_trailing_slashes (current_stat_info.file_name); + assign_string (&info->orig_file_name, name); + assign_string (&info->file_name, name); + info->had_trailing_slash = strip_trailing_slashes (info->file_name); if (recent_long_link) free (recent_long_link); @@ -459,13 +477,54 @@ read_header (bool raw_extended_headers) recent_long_link = 0; recent_long_link_blocks = 0; } - assign_string (¤t_stat_info.link_name, name); + assign_string (&info->link_name, name); return HEADER_SUCCESS; } } } +static char * +decode_xform (char *file_name, void *data) +{ + int type = *(int*)data; + + switch (type) + { + case XFORM_SYMLINK: + /* FIXME: It is not quite clear how and to which extent are the symbolic + links subject to filename transformation. In the absence of another + solution, symbolic links are exempt from component stripping and + name suffix normalization, but subject to filename transformation + proper. */ + return file_name; + + case XFORM_LINK: + file_name = safer_name_suffix (file_name, true, absolute_names_option); + break; + + case XFORM_REGFILE: + file_name = safer_name_suffix (file_name, false, absolute_names_option); + break; + } + + if (strip_name_components) + { + size_t prefix_len = stripped_prefix_len (file_name, + strip_name_components); + if (prefix_len == (size_t) -1) + prefix_len = strlen (file_name); + file_name += prefix_len; + } + return file_name; +} + +bool +transform_member_name (char **pinput, int type) +{ + return transform_name_fp (pinput, type, decode_xform, &type); +} + #define ISOCTAL(c) ((c)>='0'&&(c)<='7') /* Decode things from a file HEADER block into STAT_INFO, also setting @@ -486,7 +545,9 @@ decode_header (union block *header, struct tar_stat_info *stat_info, enum archive_format *format_pointer, int do_user_group) { enum archive_format format; - + unsigned hbits; /* high bits of the file mode. */ + mode_t mode = MODE_FROM_HEADER (header->header.mode, &hbits); + if (strcmp (header->header.magic, TMAGIC) == 0) { if (header->star_header.prefix[130] == 0 @@ -495,18 +556,18 @@ decode_header (union block *header, struct tar_stat_info *stat_info, && ISOCTAL (header->star_header.ctime[0]) && header->star_header.ctime[11] == ' ') format = STAR_FORMAT; - else if (extended_header.size) + else if (stat_info->xhdr.size) format = POSIX_FORMAT; else format = USTAR_FORMAT; } else if (strcmp (header->header.magic, OLDGNU_MAGIC) == 0) - format = OLDGNU_FORMAT; + format = hbits ? OLDGNU_FORMAT : GNU_FORMAT; else format = V7_FORMAT; *format_pointer = format; - stat_info->stat.st_mode = MODE_FROM_HEADER (header->header.mode); + stat_info->stat.st_mode = mode; stat_info->mtime.tv_sec = TIME_FROM_HEADER (header->header.mtime); stat_info->mtime.tv_nsec = 0; assign_string (&stat_info->uname, @@ -577,10 +638,22 @@ decode_header (union block *header, struct tar_stat_info *stat_info, else { stat_info->is_sparse = false; - if ((current_format == GNU_FORMAT - || current_format == OLDGNU_FORMAT) - && current_header->header.typeflag == GNUTYPE_DUMPDIR) - get_gnu_dumpdir (); + if (((current_format == GNU_FORMAT + || current_format == OLDGNU_FORMAT) + && current_header->header.typeflag == GNUTYPE_DUMPDIR) + || stat_info->dumpdir) + stat_info->is_dumpdir = true; + } + + transform_member_name (&stat_info->file_name, XFORM_REGFILE); + switch (header->header.typeflag) + { + case SYMTYPE: + transform_member_name (&stat_info->link_name, XFORM_SYMLINK); + break; + + case LNKTYPE: + transform_member_name (&stat_info->link_name, XFORM_LINK); } } @@ -611,7 +684,8 @@ from_header (char const *where0, size_t digs, char const *type, { if (type && !silent) ERROR ((0, 0, - /* TRANSLATORS: %s is type of the value (gid_t, uid_t, etc.) */ + /* TRANSLATORS: %s is type of the value (gid_t, uid_t, + etc.) */ _("Blanks in header where numeric %s value expected"), type)); return -1; @@ -828,25 +902,28 @@ minor_from_header (const char *p, size_t s) (uintmax_t) TYPE_MAXIMUM (minor_t), false, false); } +/* Convert P to the file mode, as understood by tar. + Store unrecognized mode bits (from 10th up) in HBITS. */ mode_t -mode_from_header (const char *p, size_t s) +mode_from_header (const char *p, size_t s, unsigned *hbits) { - /* Do not complain about unrecognized mode bits. */ unsigned u = from_header (p, s, "mode_t", - (uintmax_t) TYPE_MINIMUM (mode_t), TYPE_MAXIMUM (uintmax_t), false, false); - return ((u & TSUID ? S_ISUID : 0) - | (u & TSGID ? S_ISGID : 0) - | (u & TSVTX ? S_ISVTX : 0) - | (u & TUREAD ? S_IRUSR : 0) - | (u & TUWRITE ? S_IWUSR : 0) - | (u & TUEXEC ? S_IXUSR : 0) - | (u & TGREAD ? S_IRGRP : 0) - | (u & TGWRITE ? S_IWGRP : 0) - | (u & TGEXEC ? S_IXGRP : 0) - | (u & TOREAD ? S_IROTH : 0) - | (u & TOWRITE ? S_IWOTH : 0) - | (u & TOEXEC ? S_IXOTH : 0)); + mode_t mode = ((u & TSUID ? S_ISUID : 0) + | (u & TSGID ? S_ISGID : 0) + | (u & TSVTX ? S_ISVTX : 0) + | (u & TUREAD ? S_IRUSR : 0) + | (u & TUWRITE ? S_IWUSR : 0) + | (u & TUEXEC ? S_IXUSR : 0) + | (u & TGREAD ? S_IRGRP : 0) + | (u & TGWRITE ? S_IWGRP : 0) + | (u & TGEXEC ? S_IXGRP : 0) + | (u & TOREAD ? S_IROTH : 0) + | (u & TOWRITE ? S_IWOTH : 0) + | (u & TOEXEC ? S_IXOTH : 0)); + *hbits = mode ^ u; + return mode; } off_t @@ -957,9 +1034,6 @@ tartime (struct timespec t, bool full_time) they shouldn't. Unix tar is pretty random here anyway. */ -/* FIXME: Note that print_header uses the globals HEAD, HSTAT, and - HEAD_STANDARD, which must be set up in advance. Not very clean.. */ - /* Width of "user/group size", with initial value chosen heuristically. This grows as needed, though this may cause some stairstepping in the output. Make it too small and the output will @@ -972,13 +1046,16 @@ static int ugswidth = 19; USGWIDTH, some stairstepping may occur. */ static int datewidth = sizeof "YYYY-MM-DD HH:MM" - 1; -void -print_header (struct tar_stat_info *st, off_t block_ordinal) +static bool volume_label_printed = false; + +static void +simple_print_header (struct tar_stat_info *st, union block *blk, + off_t block_ordinal) { char modes[11]; char const *time_stamp; int time_stamp_len; - char *temp_name = st->orig_file_name ? st->orig_file_name : st->file_name; + char *temp_name; /* These hold formatted ints. */ char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND]; @@ -989,27 +1066,11 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) int pad; int sizelen; - if (test_label_option && current_header->header.typeflag != GNUTYPE_VOLHDR) - return; - - if (show_stored_names_option) - { - switch (subcommand_option) - { - case CAT_SUBCOMMAND: - case UPDATE_SUBCOMMAND: - case APPEND_SUBCOMMAND: - case CREATE_SUBCOMMAND: - temp_name = st->file_name ? st->file_name : st->orig_file_name; - break; - - default: - temp_name = st->orig_file_name ? st->orig_file_name : st->file_name; - } - } + if (show_transformed_names_option) + temp_name = st->file_name ? st->file_name : st->orig_file_name; else temp_name = st->orig_file_name ? st->orig_file_name : st->file_name; - + if (block_number_option) { char buf[UINTMAX_STRSIZE_BOUND]; @@ -1031,9 +1092,10 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) /* File type and modes. */ modes[0] = '?'; - switch (current_header->header.typeflag) + switch (blk->header.typeflag) { case GNUTYPE_VOLHDR: + volume_label_printed = true; modes[0] = 'V'; break; @@ -1041,10 +1103,6 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) modes[0] = 'M'; break; - case GNUTYPE_NAMES: - modes[0] = 'N'; - break; - case GNUTYPE_LONGNAME: case GNUTYPE_LONGLINK: modes[0] = 'L'; @@ -1088,7 +1146,7 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) /* Time stamp. */ - time_stamp = tartime (st->mtime, false); + time_stamp = tartime (st->mtime, full_time_option); time_stamp_len = strlen (time_stamp); if (datewidth < time_stamp_len) datewidth = time_stamp_len; @@ -1105,8 +1163,8 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) /* Try parsing it as an unsigned integer first, and as a uid_t if that fails. This method can list positive user ids that are too large to fit in a uid_t. */ - uintmax_t u = from_header (current_header->header.uid, - sizeof current_header->header.uid, 0, + uintmax_t u = from_header (blk->header.uid, + sizeof blk->header.uid, 0, (uintmax_t) 0, (uintmax_t) TYPE_MAXIMUM (uintmax_t), false, false); @@ -1115,7 +1173,7 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) else { sprintf (uform, "%ld", - (long) UID_FROM_HEADER (current_header->header.uid)); + (long) UID_FROM_HEADER (blk->header.uid)); user = uform; } } @@ -1130,8 +1188,8 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) /* Try parsing it as an unsigned integer first, and as a gid_t if that fails. This method can list positive group ids that are too large to fit in a gid_t. */ - uintmax_t g = from_header (current_header->header.gid, - sizeof current_header->header.gid, 0, + uintmax_t g = from_header (blk->header.gid, + sizeof blk->header.gid, 0, (uintmax_t) 0, (uintmax_t) TYPE_MAXIMUM (uintmax_t), false, false); @@ -1140,14 +1198,14 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) else { sprintf (gform, "%ld", - (long) GID_FROM_HEADER (current_header->header.gid)); + (long) GID_FROM_HEADER (blk->header.gid)); group = gform; } } /* Format the file size or major/minor device numbers. */ - switch (current_header->header.typeflag) + switch (blk->header.typeflag) { case CHRTYPE: case BLKTYPE: @@ -1177,7 +1235,7 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) fprintf (stdlis, " %s", quotearg (temp_name)); - switch (current_header->header.typeflag) + switch (blk->header.typeflag) { case SYMTYPE: fprintf (stdlis, " -> %s\n", quotearg (st->link_name)); @@ -1190,7 +1248,7 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) default: { char type_string[2]; - type_string[0] = current_header->header.typeflag; + type_string[0] = blk->header.typeflag; type_string[1] = '\0'; fprintf (stdlis, _(" unknown file type %s\n"), quote (type_string)); @@ -1224,19 +1282,49 @@ print_header (struct tar_stat_info *st, off_t block_ordinal) case GNUTYPE_MULTIVOL: strcpy (size, STRINGIFY_BIGINT - (UINTMAX_FROM_HEADER (current_header->oldgnu_header.offset), + (UINTMAX_FROM_HEADER (blk->oldgnu_header.offset), uintbuf)); fprintf (stdlis, _("--Continued at byte %s--\n"), size); break; - - case GNUTYPE_NAMES: - fprintf (stdlis, _("--Mangled file names--\n")); - break; } } fflush (stdlis); } + +void +print_volume_label () +{ + struct tar_stat_info vstat; + union block vblk; + enum archive_format dummy; + + memset (&vblk, 0, sizeof (vblk)); + vblk.header.typeflag = GNUTYPE_VOLHDR; + if (recent_global_header) + memcpy (vblk.header.mtime, recent_global_header->header.mtime, + sizeof vblk.header.mtime); + tar_stat_init (&vstat); + assign_string (&vstat.file_name, "."); + decode_header (&vblk, &vstat, &dummy, 0); + assign_string (&vstat.file_name, volume_label); + simple_print_header (&vstat, &vblk, 0); + tar_stat_destroy (&vstat); +} + +void +print_header (struct tar_stat_info *st, union block *blk, + off_t block_ordinal) +{ + if (current_format == POSIX_FORMAT && !volume_label_printed && volume_label) + { + print_volume_label (); + volume_label_printed = true; + } + + simple_print_header (st, blk, block_ordinal); +} + /* Print a similar line when we make a directory automatically. */ void print_for_mkdir (char *dirname, int length, mode_t mode) @@ -1280,7 +1368,7 @@ skip_file (off_t size) } mv_size_left (size); - + while (size > 0) { x = find_next_block (); @@ -1298,15 +1386,49 @@ skip_file (off_t size) void skip_member (void) { - char save_typeflag = current_header->header.typeflag; - set_next_block_after (current_header); + if (!current_stat_info.skipped) + { + char save_typeflag = current_header->header.typeflag; + set_next_block_after (current_header); - mv_begin (¤t_stat_info); + mv_begin (¤t_stat_info); - if (current_stat_info.is_sparse) - sparse_skip_file (¤t_stat_info); - else if (save_typeflag != DIRTYPE) - skip_file (current_stat_info.stat.st_size); + if (current_stat_info.is_sparse) + sparse_skip_file (¤t_stat_info); + else if (save_typeflag != DIRTYPE) + skip_file (current_stat_info.stat.st_size); + + mv_end (); + } +} - mv_end (); +void +test_archive_label () +{ + base64_init (); + name_gather (); + + open_archive (ACCESS_READ); + if (read_header (¤t_header, ¤t_stat_info, read_header_auto) + == HEADER_SUCCESS) + { + decode_header (current_header, + ¤t_stat_info, ¤t_format, 0); + if (current_header->header.typeflag == GNUTYPE_VOLHDR) + assign_string (&volume_label, current_header->header.name); + + if (volume_label) + { + if (verbose_option) + print_volume_label (); + if (!name_match (volume_label) && multi_volume_option) + { + char *s = drop_volume_label_suffix (volume_label); + name_match (s); + free (s); + } + } + } + close_archive (); + label_notfound (); }