X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=src%2Fbuffer.c;h=ef4bbac6a7f6ec3a5cac1f24d59a24bb3806c507;hb=ee168310ec4227174ace489bf5f81f8c2f91cde0;hp=5f5457a95571e531a027179b511fdb0c41763d69;hpb=cf7169a2ede9bb08b71de68fe0c8bbecf827abe6;p=tar diff --git a/src/buffer.c b/src/buffer.c index 5f5457a..ef4bbac 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -1,7 +1,8 @@ /* Buffer management for tar. Copyright (C) 1988, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001, - 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. + 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software + Foundation, Inc. Written by John Gilmore, on 1985-08-25. @@ -35,9 +36,6 @@ /* Number of retries before giving up on read. */ #define READ_ERROR_MAX 10 -/* Globbing pattern to append to volume label if initial match failed. */ -#define VOLUME_LABEL_APPEND " Volume [1-9]*" - /* Variables. */ static tarlong prev_written; /* bytes written on previous volumes */ @@ -56,7 +54,7 @@ enum access_mode access_mode; /* how do we handle the archive */ off_t records_read; /* number of records read from this archive */ off_t records_written; /* likewise, for records written */ extern off_t records_skipped; /* number of records skipped at the start - of the archive, defined in delete.c */ + of the archive, defined in delete.c */ static off_t record_start_block; /* block ordinal at record_start */ @@ -79,7 +77,6 @@ static bool read_full_records = false; /* We're reading, but we just read the last block and it's time to update. Declared in update.c - As least EXTERN like this one as possible. (?? --gray) FIXME: Either eliminate it or move it to common.h. */ extern bool time_to_start_writing; @@ -103,19 +100,94 @@ static int global_volno = 1; /* volume number to print in external bool write_archive_to_stdout; -/* Used by flush_read and flush_write to store the real info about saved - names. */ -static char *real_s_name; -static off_t real_s_totsize; -static off_t real_s_sizeleft; - /* Multi-volume tracking support */ -static char *save_name; /* name of the file we are currently writing */ -static off_t save_totsize; /* total size of file we are writing, only - valid if save_name is nonzero */ -static off_t save_sizeleft; /* where we are in the file we are writing, - only valid if save_name is nonzero */ + +/* When creating a multi-volume archive, each `bufmap' represents + a member stored (perhaps partly) in the current record buffer. + After flushing the record to the output media, all bufmaps that + represent fully written members are removed from the list, then + the sizeleft and start numbers in the remaining bufmaps are updated. + + When reading from a multi-volume archive, the list degrades to a + single element, which keeps information about the member currently + being read. +*/ + +struct bufmap +{ + struct bufmap *next; /* Pointer to the next map entry */ + size_t start; /* Offset of the first data block */ + char *file_name; /* Name of the stored file */ + off_t sizetotal; /* Size of the stored file */ + off_t sizeleft; /* Size left to read/write */ +}; +static struct bufmap *bufmap_head, *bufmap_tail; + +/* This variable, when set, inhibits updating the bufmap chain after + a write. This is necessary when writing extended POSIX headers. */ +static int inhibit_map; + +void +mv_begin_write (const char *file_name, off_t totsize, off_t sizeleft) +{ + if (multi_volume_option) + { + struct bufmap *bp = xmalloc (sizeof bp[0]); + if (bufmap_tail) + bufmap_tail->next = bp; + else + bufmap_head = bp; + bufmap_tail = bp; + + bp->next = NULL; + bp->start = current_block - record_start; + bp->file_name = xstrdup (file_name); + bp->sizetotal = totsize; + bp->sizeleft = sizeleft; + } +} + +static struct bufmap * +bufmap_locate (size_t off) +{ + struct bufmap *map; + + for (map = bufmap_head; map; map = map->next) + { + if (!map->next + || off < map->next->start * BLOCKSIZE) + break; + } + return map; +} + +static void +bufmap_free (struct bufmap *mark) +{ + struct bufmap *map; + for (map = bufmap_head; map && map != mark; ) + { + struct bufmap *next = map->next; + free (map->file_name); + free (map); + map = next; + } + bufmap_head = map; + if (!bufmap_head) + bufmap_tail = bufmap_head; +} + +static void +bufmap_reset (struct bufmap *map, ssize_t fixup) +{ + bufmap_free (map); + if (map) + { + for (; map; map = map->next) + map->start += fixup; + } +} static struct tar_stat_info dummy; @@ -127,32 +199,23 @@ buffer_write_global_xheader () } void -mv_begin (struct tar_stat_info *st) +mv_begin_read (struct tar_stat_info *st) { - if (multi_volume_option) - { - assign_string (&save_name, st->orig_file_name); - save_totsize = save_sizeleft = st->stat.st_size; - } + mv_begin_write (st->orig_file_name, st->stat.st_size, st->stat.st_size); } void mv_end () { if (multi_volume_option) - assign_string (&save_name, 0); -} - -void -mv_total_size (off_t size) -{ - save_totsize = size; + bufmap_free (NULL); } void mv_size_left (off_t size) { - save_sizeleft = size; + if (bufmap_head) + bufmap_head->sizeleft = size; } @@ -177,8 +240,8 @@ set_start_time () last_stat_time = start_time; } -void -set_volume_start_time () +static void +set_volume_start_time (void) { gettime (&volume_start_time); last_stat_time = volume_start_time; @@ -203,27 +266,31 @@ enum compress_type { ct_compress, ct_gzip, ct_bzip2, + ct_lzip, ct_lzma, - ct_lzop + ct_lzop, + ct_xz }; struct zip_magic { enum compress_type type; size_t length; - char *magic; - char *program; - char *option; + char const *magic; + char const *program; + char const *option; }; static struct zip_magic const magic[] = { { ct_tar }, { ct_none, }, - { ct_compress, 2, "\037\235", "compress", "-Z" }, - { ct_gzip, 2, "\037\213", "gzip", "-z" }, - { ct_bzip2, 3, "BZh", "bzip2", "-j" }, - { ct_lzma, 6, "\xFFLZMA", "lzma", "-J" }, /* FIXME: ???? */ - { ct_lzop, 4, "\211LZO", "lzop", "--lzop" }, + { ct_compress, 2, "\037\235", COMPRESS_PROGRAM, "-Z" }, + { ct_gzip, 2, "\037\213", GZIP_PROGRAM, "-z" }, + { ct_bzip2, 3, "BZh", BZIP2_PROGRAM, "-j" }, + { ct_lzip, 4, "LZIP", LZIP_PROGRAM, "--lzip" }, + { ct_lzma, 6, "\xFFLZMA", LZMA_PROGRAM, "--lzma" }, + { ct_lzop, 4, "\211LZO", LZOP_PROGRAM, "--lzop" }, + { ct_xz, 6, "\xFD" "7zXZ", XZ_PROGRAM, "-J" }, }; #define NMAGIC (sizeof(magic)/sizeof(magic[0])) @@ -232,7 +299,7 @@ static struct zip_magic const magic[] = { #define compress_program(t) magic[t].program /* Check if the file ARCHIVE is a compressed archive. */ -enum compress_type +static enum compress_type check_compressed_archive (bool *pshort) { struct zip_magic const *p; @@ -241,14 +308,14 @@ check_compressed_archive (bool *pshort) if (!pshort) pshort = &temp; - + /* Prepare global data needed for find_next_block: */ record_end = record_start; /* set up for 1st record = # 0 */ sfr = read_full_records; read_full_records = true; /* Suppress fatal error on reading a partial record */ *pshort = find_next_block () == 0; - + /* Restore global values */ read_full_records = sfr; @@ -263,11 +330,42 @@ check_compressed_archive (bool *pshort) return ct_none; } +/* Guess if the archive is seekable. */ +static void +guess_seekable_archive (void) +{ + struct stat st; + + if (subcommand_option == DELETE_SUBCOMMAND) + { + /* The current code in delete.c is based on the assumption that + skip_member() reads all data from the archive. So, we should + make sure it won't use seeks. On the other hand, the same code + depends on the ability to backspace a record in the archive, + so setting seekable_archive to false is technically incorrect. + However, it is tested only in skip_member(), so it's not a + problem. */ + seekable_archive = false; + } + + if (seek_option != -1) + { + seekable_archive = !!seek_option; + return; + } + + if (!multi_volume_option && !use_compress_program_option + && fstat (archive, &st) == 0) + seekable_archive = S_ISREG (st.st_mode); + else + seekable_archive = false; +} + /* Open an archive named archive_name_array[0]. Detect if it is a compressed archive of known type and use corresponding decompression program if so */ -int -open_compressed_archive () +static int +open_compressed_archive (void) { archive = rmtopen (archive_name_array[0], O_RDONLY | O_BINARY, MODE_RW, rsh_command_option); @@ -287,13 +385,13 @@ open_compressed_archive () if (shortfile) ERROR ((0, 0, _("This does not look like a tar archive"))); return archive; - + case ct_none: if (shortfile) ERROR ((0, 0, _("This does not look like a tar archive"))); - set_comression_program_by_suffix (archive_name_array[0], NULL); + set_compression_program_by_suffix (archive_name_array[0], NULL); if (!use_compress_program_option) - return archive; + return archive; break; default: @@ -301,7 +399,7 @@ open_compressed_archive () break; } } - + /* FD is not needed any more */ rmtclose (archive); @@ -453,7 +551,7 @@ xclose (int fd) } static void -init_buffer () +init_buffer (void) { if (! record_buffer_aligned[record_index]) record_buffer_aligned[record_index] = @@ -478,8 +576,6 @@ _open_archive (enum access_mode wanted_access) FATAL_ERROR ((0, 0, _("No archive name given"))); tar_stat_destroy (¤t_stat_info); - save_name = 0; - real_s_name = 0; record_index = 0; init_buffer (); @@ -563,6 +659,8 @@ _open_archive (enum access_mode wanted_access) { case ACCESS_READ: archive = open_compressed_archive (); + if (archive >= 0) + guess_seekable_archive (); break; case ACCESS_WRITE: @@ -622,7 +720,7 @@ _open_archive (enum access_mode wanted_access) } /* Perform a write to flush the buffer. */ -ssize_t +static ssize_t _flush_write (void) { ssize_t status; @@ -637,7 +735,21 @@ _flush_write (void) status = record_size; else status = sys_write_archive_buffer (); - + + if (status && multi_volume_option && !inhibit_map) + { + struct bufmap *map = bufmap_locate (status); + if (map) + { + size_t delta = status - map->start * BLOCKSIZE; + if (delta > map->sizeleft) + delta = map->sizeleft; + map->sizeleft -= delta; + if (map->sizeleft == 0) + map = map->next; + bufmap_reset (map, map ? (- map->start) : 0); + } + } return status; } @@ -677,6 +789,19 @@ archive_read_error (void) return; } +static bool +archive_is_dev (void) +{ + struct stat st; + + if (fstat (archive, &st)) + { + stat_diag (*archive_name_cursor); + return false; + } + return S_ISBLK (st.st_mode) || S_ISCHR (st.st_mode); +} + static void short_read (size_t status) { @@ -688,7 +813,8 @@ short_read (size_t status) if (left && left % BLOCKSIZE == 0 && verbose_option - && record_start_block == 0 && status != 0) + && record_start_block == 0 && status != 0 + && archive_is_dev ()) { unsigned long rsize = status / BLOCKSIZE; WARN ((0, 0, @@ -807,16 +933,16 @@ seek_archive (off_t size) off_t start = current_block_ordinal (); off_t offset; off_t nrec, nblk; - off_t skipped = (blocking_factor - (current_block - record_start)); - - size -= skipped * BLOCKSIZE; + off_t skipped = (blocking_factor - (current_block - record_start)) + * BLOCKSIZE; - if (size < record_size) + if (size <= skipped) return 0; - /* FIXME: flush? */ /* Compute number of records to skip */ - nrec = size / record_size; + nrec = (size - skipped) / record_size; + if (nrec == 0) + return 0; offset = rmtlseek (archive, nrec * record_size, SEEK_CUR); if (offset < 0) return offset; @@ -858,12 +984,9 @@ close_archive (void) sys_wait_for_child (child_pid, hit_eof); tar_stat_destroy (¤t_stat_info); - if (save_name) - free (save_name); - if (real_s_name) - free (real_s_name); free (record_buffer[0]); free (record_buffer[1]); + bufmap_free (NULL); } /* Called to initialize the global volume number. */ @@ -907,7 +1030,7 @@ closeout_volume_number (void) static void -increase_volume_number () +increase_volume_number (void) { global_volno++; if (global_volno < 0) @@ -915,13 +1038,13 @@ increase_volume_number () volno++; } -void +static void change_tape_menu (FILE *read_file) { char *input_buffer = NULL; size_t size = 0; bool stop = false; - + while (!stop) { fputc ('\007', stderr); @@ -1039,7 +1162,7 @@ new_volume (enum access_mode mode) assign_string (&continued_file_name, NULL); continued_file_size = continued_file_offset = 0; current_block = record_start; - + if (rmtclose (archive) != 0) close_error (*archive_name_cursor); @@ -1082,6 +1205,7 @@ new_volume (enum access_mode mode) case ACCESS_READ: archive = rmtopen (*archive_name_cursor, O_RDONLY, MODE_RW, rsh_command_option); + guess_seekable_archive (); break; case ACCESS_WRITE: @@ -1117,7 +1241,7 @@ read_header0 (struct tar_stat_info *info) enum read_header rc; tar_stat_init (info); - rc = read_header_primitive (false, info); + rc = read_header (¤t_header, info, read_header_auto); if (rc == HEADER_SUCCESS) { set_next_block_after (current_header); @@ -1127,13 +1251,13 @@ read_header0 (struct tar_stat_info *info) return false; } -bool -try_new_volume () +static bool +try_new_volume (void) { size_t status; union block *header; enum access_mode acc; - + switch (subcommand_option) { case APPEND_SUBCOMMAND: @@ -1149,7 +1273,7 @@ try_new_volume () if (!new_volume (acc)) return true; - + while ((status = rmtread (archive, record_start->buffer, record_size)) == SAFE_READ_ERROR) archive_read_error (); @@ -1165,17 +1289,42 @@ try_new_volume () { case XGLTYPE: { - if (!read_header0 (&dummy)) - return false; + tar_stat_init (&dummy); + if (read_header (&header, &dummy, read_header_x_global) + != HEADER_SUCCESS_EXTENDED) + { + ERROR ((0, 0, _("This does not look like a tar archive"))); + return false; + } + xheader_decode (&dummy); /* decodes values from the global header */ tar_stat_destroy (&dummy); - if (!real_s_name) - { - /* We have read the extended header of the first member in - this volume. Put it back, so next read_header works as - expected. */ - current_block = record_start; - } + + /* The initial global header must be immediately followed by + an extended PAX header for the first member in this volume. + However, in some cases tar may split volumes in the middle + of a PAX header. This is incorrect, and should be fixed + in the future versions. In the meantime we must be + prepared to correctly list and extract such archives. + + If this happens, the following call to read_header returns + HEADER_FAILURE, which is ignored. + + See also tests/multiv07.at */ + + switch (read_header (&header, &dummy, read_header_auto)) + { + case HEADER_SUCCESS: + set_next_block_after (header); + break; + + case HEADER_FAILURE: + break; + + default: + ERROR ((0, 0, _("This does not look like a tar archive"))); + return false; + } break; } @@ -1205,30 +1354,30 @@ try_new_volume () break; } - if (real_s_name) + if (bufmap_head) { uintmax_t s; if (!continued_file_name - || strcmp (continued_file_name, real_s_name)) + || strcmp (continued_file_name, bufmap_head->file_name)) { if ((archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT) - && strlen (real_s_name) >= NAME_FIELD_SIZE - && strncmp (continued_file_name, real_s_name, + && strlen (bufmap_head->file_name) >= NAME_FIELD_SIZE + && strncmp (continued_file_name, bufmap_head->file_name, NAME_FIELD_SIZE) == 0) WARN ((0, 0, _("%s is possibly continued on this volume: header contains truncated name"), - quote (real_s_name))); + quote (bufmap_head->file_name))); else { WARN ((0, 0, _("%s is not continued on this volume"), - quote (real_s_name))); + quote (bufmap_head->file_name))); return false; } } s = continued_file_size + continued_file_offset; - if (real_s_totsize != s || s < continued_file_offset) + if (bufmap_head->sizetotal != s || s < continued_file_offset) { char totsizebuf[UINTMAX_STRSIZE_BOUND]; char s1buf[UINTMAX_STRSIZE_BOUND]; @@ -1236,23 +1385,24 @@ try_new_volume () WARN ((0, 0, _("%s is the wrong size (%s != %s + %s)"), quote (continued_file_name), - STRINGIFY_BIGINT (save_totsize, totsizebuf), + STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf), STRINGIFY_BIGINT (continued_file_size, s1buf), STRINGIFY_BIGINT (continued_file_offset, s2buf))); return false; } - if (real_s_totsize - real_s_sizeleft != continued_file_offset) + if (bufmap_head->sizetotal - bufmap_head->sizeleft != + continued_file_offset) { char totsizebuf[UINTMAX_STRSIZE_BOUND]; char s1buf[UINTMAX_STRSIZE_BOUND]; char s2buf[UINTMAX_STRSIZE_BOUND]; WARN ((0, 0, _("This volume is out of sequence (%s - %s != %s)"), - STRINGIFY_BIGINT (real_s_totsize, totsizebuf), - STRINGIFY_BIGINT (real_s_sizeleft, s1buf), + STRINGIFY_BIGINT (bufmap_head->sizetotal, totsizebuf), + STRINGIFY_BIGINT (bufmap_head->sizeleft, s1buf), STRINGIFY_BIGINT (continued_file_offset, s2buf))); - + return false; } } @@ -1262,31 +1412,57 @@ try_new_volume () } -/* Check the LABEL block against the volume label, seen as a globbing +#define VOLUME_TEXT " Volume " +#define VOLUME_TEXT_LEN (sizeof VOLUME_TEXT - 1) + +char * +drop_volume_label_suffix (const char *label) +{ + const char *p; + size_t len = strlen (label); + + if (len < 1) + return NULL; + + for (p = label + len - 1; p > label && isdigit ((unsigned char) *p); p--) + ; + if (p > label && p - (VOLUME_TEXT_LEN - 1) > label) + { + p -= VOLUME_TEXT_LEN - 1; + if (memcmp (p, VOLUME_TEXT, VOLUME_TEXT_LEN) == 0) + { + char *s = xmalloc ((len = p - label) + 1); + memcpy (s, label, len); + s[len] = 0; + return s; + } + } + + return NULL; +} + +/* Check LABEL against the volume label, seen as a globbing pattern. Return true if the pattern matches. In case of failure, retry matching a volume sequence number before giving up in multi-volume mode. */ static bool -check_label_pattern (union block *label) +check_label_pattern (const char *label) { char *string; - bool result; - - if (! memchr (label->header.name, '\0', sizeof label->header.name)) - return false; + bool result = false; - if (fnmatch (volume_label_option, label->header.name, 0) == 0) + if (fnmatch (volume_label_option, label, 0) == 0) return true; if (!multi_volume_option) return false; - string = xmalloc (strlen (volume_label_option) - + sizeof VOLUME_LABEL_APPEND + 1); - strcpy (string, volume_label_option); - strcat (string, VOLUME_LABEL_APPEND); - result = fnmatch (string, label->header.name, 0) == 0; - free (string); + string = drop_volume_label_suffix (label); + if (string) + { + result = fnmatch (string, volume_label_option, 0) == 0; + free (string); + } return result; } @@ -1295,14 +1471,43 @@ check_label_pattern (union block *label) static void match_volume_label (void) { - union block *label = find_next_block (); + if (!volume_label) + { + union block *label = find_next_block (); + + if (!label) + FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"), + quote (volume_label_option))); + if (label->header.typeflag == GNUTYPE_VOLHDR) + { + if (memchr (label->header.name, '\0', sizeof label->header.name)) + assign_string (&volume_label, label->header.name); + else + { + volume_label = xmalloc (sizeof (label->header.name) + 1); + memcpy (volume_label, label->header.name, + sizeof (label->header.name)); + volume_label[sizeof (label->header.name)] = 0; + } + } + else if (label->header.typeflag == XGLTYPE) + { + struct tar_stat_info st; + tar_stat_init (&st); + xheader_read (&st.xhdr, label, + OFF_FROM_HEADER (label->header.size)); + xheader_decode (&st); + tar_stat_destroy (&st); + } + } - if (!label) + if (!volume_label) FATAL_ERROR ((0, 0, _("Archive not labeled to match %s"), quote (volume_label_option))); - if (!check_label_pattern (label)) + + if (!check_label_pattern (volume_label)) FATAL_ERROR ((0, 0, _("Volume %s does not match %s"), - quote_n (0, label->header.name), + quote_n (0, volume_label), quote_n (1, volume_label_option))); } @@ -1347,26 +1552,24 @@ add_volume_label (void) } static void -add_chunk_header () +add_chunk_header (struct bufmap *map) { if (archive_format == POSIX_FORMAT) { off_t block_ordinal; union block *blk; struct tar_stat_info st; - static size_t real_s_part_no; /* FIXME */ - real_s_part_no++; memset (&st, 0, sizeof st); - st.orig_file_name = st.file_name = real_s_name; + st.orig_file_name = st.file_name = map->file_name; st.stat.st_mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH; st.stat.st_uid = getuid (); st.stat.st_gid = getgid (); st.orig_file_name = xheader_format_name (&st, "%d/GNUFileParts.%p/%f.%n", - real_s_part_no); + volno); st.file_name = st.orig_file_name; - st.archive_file_size = st.stat.st_size = real_s_sizeleft; + st.archive_file_size = st.stat.st_size = map->sizeleft; block_ordinal = current_block_ordinal (); blk = start_header (&st); @@ -1390,27 +1593,23 @@ write_volume_label (void) /* Write GNU multi-volume header */ static void -gnu_add_multi_volume_header (void) +gnu_add_multi_volume_header (struct bufmap *map) { int tmp; union block *block = find_next_block (); - if (strlen (real_s_name) > NAME_FIELD_SIZE) + if (strlen (map->file_name) > NAME_FIELD_SIZE) WARN ((0, 0, _("%s: file name too long to be stored in a GNU multivolume header, truncated"), - quotearg_colon (real_s_name))); + quotearg_colon (map->file_name))); memset (block, 0, BLOCKSIZE); - /* FIXME: Michael P Urban writes: [a long name file] is being written - when a new volume rolls around [...] Looks like the wrong value is - being preserved in real_s_name, though. */ - - strncpy (block->header.name, real_s_name, NAME_FIELD_SIZE); + strncpy (block->header.name, map->file_name, NAME_FIELD_SIZE); block->header.typeflag = GNUTYPE_MULTIVOL; - OFF_TO_CHARS (real_s_sizeleft, block->header.size); - OFF_TO_CHARS (real_s_totsize - real_s_sizeleft, + OFF_TO_CHARS (map->sizeleft, block->header.size); + OFF_TO_CHARS (map->sizetotal - map->sizeleft, block->oldgnu_header.offset); tmp = verbose_option; @@ -1423,40 +1622,17 @@ gnu_add_multi_volume_header (void) /* Add a multi volume header to the current archive. The exact header format depends on the archive format. */ static void -add_multi_volume_header (void) +add_multi_volume_header (struct bufmap *map) { if (archive_format == POSIX_FORMAT) { - off_t d = real_s_totsize - real_s_sizeleft; - xheader_store ("GNU.volume.filename", &dummy, real_s_name); - xheader_store ("GNU.volume.size", &dummy, &real_s_sizeleft); + off_t d = map->sizetotal - map->sizeleft; + xheader_store ("GNU.volume.filename", &dummy, map->file_name); + xheader_store ("GNU.volume.size", &dummy, &map->sizeleft); xheader_store ("GNU.volume.offset", &dummy, &d); } else - gnu_add_multi_volume_header (); -} - -/* Synchronize multi-volume globals */ -static void -multi_volume_sync () -{ - if (multi_volume_option) - { - if (save_name) - { - assign_string (&real_s_name, - safer_name_suffix (save_name, false, - absolute_names_option)); - real_s_totsize = save_totsize; - real_s_sizeleft = save_sizeleft; - } - else - { - assign_string (&real_s_name, 0); - real_s_totsize = 0; - real_s_sizeleft = 0; - } - } + gnu_add_multi_volume_header (map); } @@ -1469,7 +1645,7 @@ simple_flush_read (void) size_t status; /* result from system call */ checkpoint_run (false); - + /* Clear the count of errors. This only applies to a single call to flush_read. */ @@ -1528,7 +1704,7 @@ _gnu_flush_read (void) size_t status; /* result from system call */ checkpoint_run (false); - + /* Clear the count of errors. This only applies to a single call to flush_read. */ @@ -1543,8 +1719,6 @@ _gnu_flush_read (void) archive_write_error (status); } - multi_volume_sync (); - for (;;) { status = rmtread (archive, record_start->buffer, record_size); @@ -1596,36 +1770,36 @@ _gnu_flush_write (size_t buffer_level) char *copy_ptr; size_t copy_size; size_t bufsize; - tarlong wrt; - + struct bufmap *map; + status = _flush_write (); if (status != record_size && !multi_volume_option) archive_write_error (status); else { if (status) - records_written++; + records_written++; bytes_written += status; } if (status == record_size) { - multi_volume_sync (); return; } + map = bufmap_locate (status); + if (status % BLOCKSIZE) { ERROR ((0, 0, _("write did not end on a block boundary"))); archive_write_error (status); } - + /* In multi-volume mode. */ /* ENXIO is for the UNIX PC. */ if (status < 0 && errno != ENOSPC && errno != EIO && errno != ENXIO) archive_write_error (status); - real_s_sizeleft -= status; if (!new_volume (ACCESS_WRITE)) return; @@ -1637,25 +1811,28 @@ _gnu_flush_write (size_t buffer_level) copy_ptr = record_start->buffer + status; copy_size = buffer_level - status; - + /* Switch to the next buffer */ record_index = !record_index; init_buffer (); + inhibit_map = 1; + if (volume_label_option) add_volume_label (); - if (real_s_name) - add_multi_volume_header (); + if (map) + add_multi_volume_header (map); write_extended (true, &dummy, find_next_block ()); tar_stat_destroy (&dummy); - - if (real_s_name) - add_chunk_header (); - wrt = bytes_written; + + if (map) + add_chunk_header (map); header = find_next_block (); + bufmap_reset (map, header - record_start); bufsize = available_space_after (header); + inhibit_map = 0; while (bufsize < copy_size) { memcpy (header->buffer, copy_ptr, bufsize); @@ -1668,16 +1845,6 @@ _gnu_flush_write (size_t buffer_level) memcpy (header->buffer, copy_ptr, copy_size); memset (header->buffer + copy_size, 0, bufsize - copy_size); set_next_block_after (header + (copy_size - 1) / BLOCKSIZE); - if (multi_volume_option && wrt < bytes_written) - { - /* The value of bytes_written has changed while moving data; - that means that flush_archive was executed at least once in - between, and, as a consequence, copy_size bytes were not written - to disk. We need to update sizeleft variables to compensate for - that. */ - save_sizeleft += copy_size; - multi_volume_sync (); - } find_next_block (); } @@ -1711,6 +1878,7 @@ open_archive (enum access_mode wanted_access) switch (wanted_access) { case ACCESS_READ: + case ACCESS_UPDATE: if (volume_label_option) match_volume_label (); break; @@ -1720,9 +1888,6 @@ open_archive (enum access_mode wanted_access) if (volume_label_option) write_volume_label (); break; - - default: - break; } set_volume_start_time (); }