X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Flist.c;h=474651c5c1cbb4273ad9c30a85f4fca8723e8e2b;hb=6dccec3ba45c8c5052be0dacb7c4766662ed30fc;hp=7a9bd5079b4f0dc5da34fe208e4f7e3034c8f153;hpb=e1ac06bccae865dc1cd7266302961a0ff68716b3;p=chaz%2Ftar diff --git a/src/list.c b/src/list.c index 7a9bd50..474651c 100644 --- a/src/list.c +++ b/src/list.c @@ -1,5 +1,5 @@ /* List a tar archive, with support routines for reading a tar archive. - Copyright (C) 1988, 92, 93, 94, 96, 97 Free Software Foundation, Inc. + Copyright 1988,92,93,94,96,97,98,1999 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 @@ -14,30 +14,40 @@ 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 Place - Suite 330, Boston, MA 02111-1307, USA. */ + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Define to non-zero for forcing old ctime() instead of isotime(). */ #undef USE_OLD_CTIME #include "system.h" +#include -#include #include -#define ISODIGIT(Char) \ - ((unsigned char) (Char) >= '0' && (unsigned char) (Char) <= '7') -#define ISSPACE(Char) (ISASCII (Char) && isspace (Char)) - -#ifndef FNM_LEADING_DIR -# include -#endif - #include "common.h" +#define max(a, b) ((a) < (b) ? (b) : (a)) + union block *current_header; /* points to current archive header */ struct stat current_stat; /* stat struct corresponding */ enum archive_format current_format; /* recognized format */ +static uintmax_t from_chars PARAMS ((const char *, size_t, const char *, + uintmax_t, uintmax_t)); + +/* Table of base 64 digit values indexed by unsigned chars. + The value is 64 for unsigned chars that are not base 64 digits. */ +static char base64_map[1 + (unsigned char) -1]; + +static void +base64_init (void) +{ + int i; + memset (base64_map, 64, sizeof base64_map); + for (i = 0; i < 64; i++) + base64_map[(int) base_64_digits[i]] = i; +} + /*-----------------------------------. | Main loop for reading an archive. | `-----------------------------------*/ @@ -47,8 +57,8 @@ read_and (void (*do_something) ()) { enum read_header status = HEADER_STILL_UNREAD; enum read_header prev_status; - char save_typeflag; + base64_init (); name_gather (); open_archive (ACCESS_READ); @@ -66,20 +76,15 @@ read_and (void (*do_something) ()) /* Valid header. We should decode next field (mode) first. Ensure incoming names are null terminated. */ - if (ending_file_option && - fnmatch (ending_file_option, current_file_name, - FNM_LEADING_DIR) == 0) { - goto all_done; - } - /* FIXME: This is a quick kludge before 1.12 goes out. */ - current_stat.st_mtime = TIME_FROM_OCT (current_header->header.mtime); + current_stat.st_mtime + = TIME_FROM_CHARS (current_header->header.mtime); if (!name_match (current_file_name) || current_stat.st_mtime < newer_mtime_option - || (exclude_option && check_exclude (current_file_name))) + || excluded_name (current_file_name)) { - int isextended = 0; + char save_typeflag; if (current_header->header.typeflag == GNUTYPE_VOLHDR || current_header->header.typeflag == GNUTYPE_MULTIVOL @@ -94,28 +99,10 @@ read_and (void (*do_something) ()) /* Skip past it in the archive. */ - if (current_header->oldgnu_header.isextended) - isextended = 1; save_typeflag = current_header->header.typeflag; set_next_block_after (current_header); - if (isextended) - { -#if 0 - union block *exhdr; - - while (1) - { - exhdr = find_next_block (); - if (!exhdr->sparse_header.isextended) - { - set_next_block_after (exhdr); - break; - } - } - set_next_block_after (exhdr); -#endif - skip_extended_headers (); - } + if (current_header->oldgnu_header.isextended) + skip_extended_headers (); /* Skip to the next header on the archive. */ @@ -174,7 +161,6 @@ read_and (void (*do_something) ()) } break; } - all_done: ; apply_delayed_set_stat (); close_archive (); @@ -188,8 +174,6 @@ read_and (void (*do_something) ()) void list_archive (void) { - int isextended = 0; /* to remember if current_header is extended */ - /* Print the header block. */ if (verbose_option) @@ -245,37 +229,11 @@ list_archive (void) } - /* Check to see if we have an extended header to skip over also. */ - - if (current_header->oldgnu_header.isextended) - isextended = 1; - - /* Skip past the header in the archive. */ + /* Skip past the header in the archive, and past any extended headers. */ set_next_block_after (current_header); - - /* If we needed to skip any extended headers, do so now, by reading - extended headers and skipping past them in the archive. */ - - if (isextended) - { -#if 0 - union block *exhdr; - - while (1) - { - exhdr = find_next_block (); - - if (!exhdr->sparse_header.isextended) - { - set_next_block_after (exhdr); - break; - } - set_next_block_after (exhdr); - } -#endif - skip_extended_headers (); - } + if (current_header->oldgnu_header.isextended) + skip_extended_headers (); if (multi_volume_option) assign_string (&save_name, current_file_name); @@ -309,16 +267,14 @@ list_archive (void) a name containing characters with the high bit set. So read_header computes two checksums -- signed and unsigned. */ -/* FIXME: The signed checksum computation is broken on machines where char's - are unsigned. It's uneasy to handle all cases correctly... */ - enum read_header read_header (void) { size_t i; - long unsigned_sum; /* the POSIX one :-) */ - long signed_sum; /* the Sun one :-( */ - long recorded_sum; + int unsigned_sum; /* the POSIX one :-) */ + int signed_sum; /* the Sun one :-( */ + int recorded_sum; + uintmax_t parsed_sum; char *p; union block *header; char **longp; @@ -334,37 +290,36 @@ read_header (void) if (!header) return HEADER_END_OF_FILE; - recorded_sum = UINTMAX_FROM_OCT (header->header.chksum); - unsigned_sum = 0; signed_sum = 0; p = header->buffer; for (i = sizeof (*header); i-- != 0;) { - /* We can't use unsigned char here because of old compilers, - e.g. V7. */ - - unsigned_sum += 0xFF & *p; - signed_sum += *p++; + unsigned_sum += (unsigned char) *p; + signed_sum += signed_char (*p++); } + if (unsigned_sum == 0) + return HEADER_ZERO_BLOCK; + /* Adjust checksum to count the "chksum" field as blanks. */ for (i = sizeof (header->header.chksum); i-- != 0;) { - unsigned_sum -= 0xFF & header->header.chksum[i]; - signed_sum -= header->header.chksum[i]; + unsigned_sum -= (unsigned char) header->header.chksum[i]; + signed_sum -= signed_char (header->header.chksum[i]); } unsigned_sum += ' ' * sizeof header->header.chksum; signed_sum += ' ' * sizeof header->header.chksum; - if (unsigned_sum == sizeof header->header.chksum * ' ') - { - /* This is a zeroed block...whole block is 0's except for the - blanks we faked for the checksum field. */ + parsed_sum = from_chars (header->header.chksum, + sizeof header->header.chksum, + (char *) 0, (uintmax_t) 0, + (uintmax_t) TYPE_MAXIMUM (int)); + if (parsed_sum == (uintmax_t) -1) + return HEADER_FAILURE; - return HEADER_ZERO_BLOCK; - } + recorded_sum = parsed_sum; if (unsigned_sum != recorded_sum && signed_sum != recorded_sum) return HEADER_FAILURE; @@ -374,9 +329,8 @@ read_header (void) if (header->header.typeflag == LNKTYPE) current_stat.st_size = 0; /* links 0 size on tape */ else - current_stat.st_size = OFF_FROM_OCT (header->header.size); + current_stat.st_size = OFF_FROM_CHARS (header->header.size); - header->header.name[NAME_FIELD_SIZE - 1] = '\0'; if (header->header.typeflag == GNUTYPE_LONGNAME || header->header.typeflag == GNUTYPE_LONGLINK) { @@ -415,16 +369,19 @@ read_header (void) } else { - char *name = next_long_name; + char *name; struct posix_header *h = ¤t_header->header; - char namebuf[sizeof h->prefix + 1 + sizeof h->name + 1]; + char namebuf[sizeof h->prefix + 1 + NAME_FIELD_SIZE + 1]; + name = next_long_name; if (! name) { /* Accept file names as specified by POSIX.1-1996 section 10.1.1. */ + int posix_header = strcmp (h->magic, TMAGIC) == 0; char *np = namebuf; - if (h->prefix[0]) + + if (posix_header && h->prefix[0]) { memcpy (np, h->prefix, sizeof h->prefix); np[sizeof h->prefix] = '\0'; @@ -435,12 +392,27 @@ read_header (void) np[sizeof h->name] = '\0'; name = namebuf; } - assign_string (¤t_file_name, name); - assign_string (¤t_link_name, - (next_long_link ? next_long_link - : current_header->header.linkname)); - next_long_link = next_long_name = 0; + if (next_long_name) + { + free (next_long_name); + next_long_name = 0; + } + + name = next_long_link; + if (! name) + { + memcpy (namebuf, h->linkname, sizeof h->linkname); + namebuf[sizeof h->linkname] = '\0'; + name = namebuf; + } + assign_string (¤t_link_name, name); + if (next_long_link) + { + free (next_long_link); + next_long_link = 0; + } + return HEADER_SUCCESS; } } @@ -476,20 +448,19 @@ decode_header (union block *header, struct stat *stat_info, format = V7_FORMAT; *format_pointer = format; - stat_info->st_mode = MODE_FROM_OCT (header->header.mode); - stat_info->st_mode &= 07777; - stat_info->st_mtime = TIME_FROM_OCT (header->header.mtime); + stat_info->st_mode = MODE_FROM_CHARS (header->header.mode); + stat_info->st_mtime = TIME_FROM_CHARS (header->header.mtime); if (format == OLDGNU_FORMAT && incremental_option) { - stat_info->st_atime = TIME_FROM_OCT (header->oldgnu_header.atime); - stat_info->st_ctime = TIME_FROM_OCT (header->oldgnu_header.ctime); + stat_info->st_atime = TIME_FROM_CHARS (header->oldgnu_header.atime); + stat_info->st_ctime = TIME_FROM_CHARS (header->oldgnu_header.ctime); } if (format == V7_FORMAT) { - stat_info->st_uid = UID_FROM_OCT (header->header.uid); - stat_info->st_gid = GID_FROM_OCT (header->header.gid); + stat_info->st_uid = UID_FROM_CHARS (header->header.uid); + stat_info->st_gid = GID_FROM_CHARS (header->header.gid); stat_info->st_rdev = 0; } else @@ -501,30 +472,26 @@ decode_header (union block *header, struct stat *stat_info, if (numeric_owner_option || !*header->header.uname || !uname_to_uid (header->header.uname, &stat_info->st_uid)) - stat_info->st_uid = UID_FROM_OCT (header->header.uid); + stat_info->st_uid = UID_FROM_CHARS (header->header.uid); if (numeric_owner_option || !*header->header.gname || !gname_to_gid (header->header.gname, &stat_info->st_gid)) - stat_info->st_gid = GID_FROM_OCT (header->header.gid); + stat_info->st_gid = GID_FROM_CHARS (header->header.gid); } switch (header->header.typeflag) { -#ifdef S_IFBLK case BLKTYPE: stat_info->st_rdev - = makedev (MAJOR_FROM_OCT (header->header.devmajor), - MINOR_FROM_OCT (header->header.devminor)); + = makedev (MAJOR_FROM_CHARS (header->header.devmajor), + MINOR_FROM_CHARS (header->header.devminor)); break; -#endif -#ifdef S_IFCHR case CHRTYPE: stat_info->st_rdev - = makedev (MAJOR_FROM_OCT (header->header.devmajor), - MINOR_FROM_OCT (header->header.devminor)); + = makedev (MAJOR_FROM_CHARS (header->header.devmajor), + MINOR_FROM_CHARS (header->header.devminor)); break; -#endif default: stat_info->st_rdev = 0; @@ -533,105 +500,192 @@ decode_header (union block *header, struct stat *stat_info, } /*------------------------------------------------------------------------. -| Quick and dirty octal conversion. Result is -1 if the field is invalid | -| (all blank, or nonoctal). | +| Convert buffer at WHERE0 of size DIGS from external format to uintmax_t.| +| The data is of type TYPE. The buffer must represent a value in the | +| range -MINUS_MINVAL through MAXVAL. | `------------------------------------------------------------------------*/ static uintmax_t -from_oct (const char *where0, size_t digs0, const char *type, uintmax_t maxval) +from_chars (char const *where0, size_t digs, char const *type, + uintmax_t minus_minval, uintmax_t maxval) { uintmax_t value; - const char *where = where0; - size_t digs = digs0; + char const *where = where0; + char const *lim = where + digs; + int negative = 0; + /* Accommodate buggy tar of unknown vintage, which outputs leading + NUL if the previous field overflows. */ + where += !*where; + + /* Accommodate older tars, which output leading spaces. */ for (;;) { - if (digs == 0) + if (where == lim) { - ERROR ((0, 0, _("Blanks in header where octal %s value expected"), - type)); + if (type) + ERROR ((0, 0, + _("Blanks in header where numeric %s value expected"), + type)); return -1; } - if (!ISSPACE (*where)) + if (!ISSPACE ((unsigned char) *where)) break; where++; - digs--; } value = 0; - while (digs != 0 && ISODIGIT (*where)) + if (ISODIGIT (*where)) { - /* Scan til nonoctal. */ + do + { + if (value << LG_8 >> LG_8 != value) + goto out_of_range; + value = (value << LG_8) | (*where++ - '0'); + } + while (where != lim && ISODIGIT (*where)); - if (value << 3 >> 3 != value) - goto out_of_range; - value = (value << 3) | (*where++ - '0'); - --digs; + /* Parse the output of older tars, which output negative values + in two's complement octal. This method works only if the + type has the same number of bits as it did on the host that + created the tar file, but that's the best we can do. */ + if (maxval < value && value - maxval <= minus_minval) + { + value = minus_minval - (value - maxval); + negative = 1; + } + } + else if (*where == '-' || *where == '+') + { + int dig; + negative = *where++ == '-'; + while (where != lim + && (dig = base64_map[(unsigned char) *where]) < 64) + { + if (value << LG_64 >> LG_64 != value) + goto out_of_range; + value = (value << LG_64) | dig; + where++; + } } - if (digs != 0 && *where && !ISSPACE (*where)) + if (where != lim && *where && !ISSPACE ((unsigned char) *where)) { - ERROR ((0, 0, _("Header contains `%.*s' where octal %s value expected"), - (int) digs0, where0, type)); + if (type) + { + char buf[1000]; /* Big enough to represent any header. */ + static struct quoting_options *o; + + if (!o) + { + o = clone_quoting_options ((struct quoting_options *) 0); + set_quoting_style (o, c_quoting_style); + } + + while (where0 != lim && ! lim[-1]) + lim--; + quotearg_buffer (buf, sizeof buf, where0, lim - where, o); + ERROR ((0, 0, + _("Header contains `%.*s' where numeric %s value expected"), + (int) sizeof buf, buf, type)); + } + return -1; } - if (value <= maxval) - return value; + if (value <= (negative ? minus_minval : maxval)) + return negative ? -value : value; out_of_range: - ERROR ((0, 0, _("Octal value `%.*s' is out of range for %s"), - (int) digs0, where0, type)); + if (type) + ERROR ((0, 0, _("Numeric value `%.*s' is out of range for %s"), + (int) digs, where0, type)); return -1; } + gid_t -gid_from_oct (const char *p, size_t s) +gid_from_chars (const char *p, size_t s) { - return from_oct (p, s, "gid_t", GID_MAX); + return from_chars (p, s, "gid_t", + - (uintmax_t) TYPE_MINIMUM (gid_t), + (uintmax_t) TYPE_MAXIMUM (gid_t)); } + major_t -major_from_oct (const char *p, size_t s) +major_from_chars (const char *p, size_t s) { - return from_oct (p, s, "major_t", MAJOR_MAX); + return from_chars (p, s, "major_t", + - (uintmax_t) TYPE_MINIMUM (major_t), + (uintmax_t) TYPE_MAXIMUM (major_t)); } + minor_t -minor_from_oct (const char *p, size_t s) +minor_from_chars (const char *p, size_t s) { - return from_oct (p, s, "minor_t", MINOR_MAX); + return from_chars (p, s, "minor_t", + - (uintmax_t) TYPE_MINIMUM (minor_t), + (uintmax_t) TYPE_MAXIMUM (minor_t)); } + mode_t -mode_from_oct (const char *p, size_t s) +mode_from_chars (const char *p, size_t s) { - return from_oct (p, s, "mode_t", MODE_MAX); + /* Do not complain about unrecognized mode bits. */ + unsigned u = from_chars (p, s, "mode_t", + - (uintmax_t) TYPE_MINIMUM (mode_t), + TYPE_MAXIMUM (uintmax_t)); + 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)); } + off_t -off_from_oct (const char *p, size_t s) +off_from_chars (const char *p, size_t s) { - return from_oct (p, s, "off_t", OFF_MAX); + return from_chars (p, s, "off_t", + - (uintmax_t) TYPE_MINIMUM (off_t), + (uintmax_t) TYPE_MAXIMUM (off_t)); } + size_t -size_from_oct (const char *p, size_t s) +size_from_chars (const char *p, size_t s) { - return from_oct (p, s, "size_t", SIZE_MAX); + return from_chars (p, s, "size_t", (uintmax_t) 0, + (uintmax_t) TYPE_MAXIMUM (size_t)); } + time_t -time_from_oct (const char *p, size_t s) +time_from_chars (const char *p, size_t s) { - return from_oct (p, s, "time_t", TIME_MAX); + return from_chars (p, s, "time_t", + - (uintmax_t) TYPE_MINIMUM (time_t), + (uintmax_t) TYPE_MAXIMUM (time_t)); } + uid_t -uid_from_oct (const char *p, size_t s) +uid_from_chars (const char *p, size_t s) { - return from_oct (p, s, "uid_t", UID_MAX); + return from_chars (p, s, "uid_t", (uintmax_t) 0, + (uintmax_t) TYPE_MAXIMUM (uid_t)); } + uintmax_t -uintmax_from_oct (const char *p, size_t s) +uintmax_from_chars (const char *p, size_t s) { - return from_oct (p, s, "uintmax_t", UINTMAX_MAX); + return from_chars (p, s, "uintmax_t", (uintmax_t) 0, + TYPE_MAXIMUM (uintmax_t)); } - /*----------------------------------------------------------------------. | Format O as a null-terminated decimal string into BUF _backwards_; | | return pointer to start of result. | @@ -654,17 +708,34 @@ stringify_uintmax_t_backwards (uintmax_t o, char *buf) /* Also, see http://www.ft.uni-erlangen.de/~mskuhn/iso-time.html. */ -static char * -isotime (const time_t *time) +static char const * +isotime (time_t time) { - static char buffer[21]; - struct tm *tm; - - tm = localtime (time); - sprintf (buffer, "%4d-%02d-%02d %02d:%02d:%02d\n", - tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, - tm->tm_hour, tm->tm_min, tm->tm_sec); - return buffer; + static char buffer[max (UINTMAX_STRSIZE_BOUND + 1, + INT_STRLEN_BOUND (int) + 16)]; + struct tm *tm = localtime (&time); + if (tm) + { + sprintf (buffer, "%04d-%02d-%02d %02d:%02d:%02d", + tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, + tm->tm_hour, tm->tm_min, tm->tm_sec); + return buffer; + } + else + { + /* The timestamp cannot be broken down, most likely because it + is a huge timestamp. Convert it as an integer, + right-adjusted in a field with the same width as the usual + 19-byte 4-year ISO time format. */ + uintmax_t abstime = time < 0 ? - (uintmax_t) time : time; + char *p = stringify_uintmax_t_backwards (abstime, + buffer + sizeof buffer); + if (time < 0) + *--p = '-'; + while (buffer + sizeof buffer - 19 - 1 < p) + *--p = ' '; + return p; + } } #endif /* not USE_OLD_CTIME */ @@ -677,25 +748,21 @@ isotime (const time_t *time) static void decode_mode (mode_t mode, char *string) { - mode_t mask; - const char *rwx = "rwxrwxrwx"; - - for (mask = 0400; mask != 0; mask >>= 1) - if (mode & mask) - *string++ = *rwx++; - else - { - *string++ = '-'; - rwx++; - } - - if (mode & S_ISUID) - string[-7] = string[-7] == 'x' ? 's' : 'S'; - if (mode & S_ISGID) - string[-4] = string[-4] == 'x' ? 's' : 'S'; - if (mode & S_ISVTX) - string[-1] = string[-1] == 'x' ? 't' : 'T'; - + *string++ = mode & S_IRUSR ? 'r' : '-'; + *string++ = mode & S_IWUSR ? 'w' : '-'; + *string++ = (mode & S_ISUID + ? (mode & S_IXUSR ? 's' : 'S') + : (mode & S_IXUSR ? 'x' : '-')); + *string++ = mode & S_IRGRP ? 'r' : '-'; + *string++ = mode & S_IWGRP ? 'w' : '-'; + *string++ = (mode & S_ISGID + ? (mode & S_IXGRP ? 's' : 'S') + : (mode & S_IXGRP ? 'x' : '-')); + *string++ = mode & S_IROTH ? 'r' : '-'; + *string++ = mode & S_IWOTH ? 'w' : '-'; + *string++ = (mode & S_ISVTX + ? (mode & S_IXOTH ? 't' : 'T') + : (mode & S_IXOTH ? 'x' : '-')); *string = '\0'; } @@ -729,8 +796,9 @@ void print_header (void) { char modes[11]; - char *timestamp; - char uform[11], gform[11]; /* these hold formatted ints */ + char const *timestamp; + /* These hold formatted ints. */ + char uform[UINTMAX_STRSIZE_BOUND], gform[UINTMAX_STRSIZE_BOUND]; char *user, *group; char size[2 * UINTMAX_STRSIZE_BOUND]; /* holds formatted size or major,minor */ @@ -821,26 +889,37 @@ print_header (void) longie = current_stat.st_mtime; #if USE_OLD_CTIME - timestamp = ctime (&longie); - timestamp[16] = '\0'; - timestamp[24] = '\0'; + { + char *ct = ctime (&longie); + if (ct) + { + timestamp = ct + 4; + for (ct += 16; ct[4] != '\n'; ct++) + ct[0] = ct[4]; + ct[0] = '\0'; + } + else + timestamp = "??? ?? ??:?? ????"; + } #else - timestamp = isotime (&longie); - timestamp[16] = '\0'; + timestamp = isotime (longie); #endif /* User and group names. */ - if (*current_header->header.uname && current_format != V7_FORMAT) + if (*current_header->header.uname && current_format != V7_FORMAT + && !numeric_owner_option) user = current_header->header.uname; else - user = STRINGIFY_BIGINT (UINTMAX_FROM_OCT (current_header->header.uid), + user = STRINGIFY_BIGINT (UINTMAX_FROM_CHARS + (current_header->header.uid), uform); - if (*current_header->header.gname && current_format != V7_FORMAT) + if (*current_header->header.gname && current_format != V7_FORMAT + && !numeric_owner_option) group = current_header->header.gname; else - group = STRINGIFY_BIGINT (UINTMAX_FROM_OCT + group = STRINGIFY_BIGINT (UINTMAX_FROM_CHARS (current_header->header.gid), gform); @@ -848,18 +927,18 @@ print_header (void) switch (current_header->header.typeflag) { -#if defined(S_IFBLK) || defined(S_IFCHR) case CHRTYPE: case BLKTYPE: - sprintf (size, "%lu,%lu", - (unsigned long) major (current_stat.st_rdev), - (unsigned long) minor (current_stat.st_rdev)); + strcpy (size, + STRINGIFY_BIGINT (major (current_stat.st_rdev), uintbuf)); + strcat (size, ","); + strcat (size, + STRINGIFY_BIGINT (minor (current_stat.st_rdev), uintbuf)); break; -#endif case GNUTYPE_SPARSE: strcpy (size, STRINGIFY_BIGINT - (UINTMAX_FROM_OCT (current_header->oldgnu_header.realsize), + (UINTMAX_FROM_CHARS (current_header->oldgnu_header.realsize), uintbuf)); break; default: @@ -873,14 +952,8 @@ print_header (void) if (pad > ugswidth) ugswidth = pad; -#if USE_OLD_CTIME - fprintf (stdlis, "%s %s/%s %*s%s %s %s", - modes, user, group, ugswidth - pad, "", - size, timestamp + 4, timestamp + 20); -#else fprintf (stdlis, "%s %s/%s %*s%s %s", modes, user, group, ugswidth - pad, "", size, timestamp); -#endif name = quote_copy_string (current_file_name); if (name) @@ -939,7 +1012,7 @@ print_header (void) case GNUTYPE_MULTIVOL: strcpy (size, STRINGIFY_BIGINT - (UINTMAX_FROM_OCT (current_header->oldgnu_header.offset), + (UINTMAX_FROM_CHARS (current_header->oldgnu_header.offset), uintbuf)); fprintf (stdlis, _("--Continued at byte %s--\n"), size); break; @@ -1025,14 +1098,12 @@ skip_extended_headers (void) { union block *exhdr; - while (1) + do { exhdr = find_next_block (); - if (!exhdr->sparse_header.isextended) - { - set_next_block_after (exhdr); - break; - } + if (!exhdr) + FATAL_ERROR ((0, 0, _("Unexpected EOF on archive file"))); set_next_block_after (exhdr); } + while (exhdr->sparse_header.isextended); }