#include "system.h"
#if HAVE_UTIME_H
# include <utime.h>
#else
struct utimbuf
{
long actime;
long modtime;
};
#endif
#if HAVE_LINUX_FD_H
# include <linux/fd.h>
#endif
#include <quotearg.h>
#include "common.h"
#include "rmt.h"
#define MESSAGE_BUFFER_SIZE 100
int now_verifying;
static int diff_handle;
static char *diff_buffer;
void
diff_init (void)
{
diff_buffer = valloc (record_size);
if (!diff_buffer)
xalloc_die ();
}
static void
report_difference (const char *message)
{
if (message)
fprintf (stdlis, "%s: %s\n", quotearg_colon (current_file_name), message);
if (exit_status == TAREXIT_SUCCESS)
exit_status = TAREXIT_DIFFERS;
}
static int
process_noop (size_t size, char *data)
{
return 1;
}
static int
process_rawdata (size_t bytes, char *buffer)
{
ssize_t status = safe_read (diff_handle, diff_buffer, bytes);
char message[MESSAGE_BUFFER_SIZE];
if (status != bytes)
{
if (status < 0)
{
read_error (current_file_name);
report_difference (0);
}
else
{
sprintf (message, _("Could only read %lu of %lu bytes"),
(unsigned long) status, (unsigned long) bytes);
report_difference (message);
}
return 0;
}
if (memcmp (buffer, diff_buffer, bytes))
{
report_difference (_("Contents differ"));
return 0;
}
return 1;
}
static char *dumpdir_cursor;
static int
process_dumpdir (size_t bytes, char *buffer)
{
if (memcmp (buffer, dumpdir_cursor, bytes))
{
report_difference (_("Contents differ"));
return 0;
}
dumpdir_cursor += bytes;
return 1;
}
static void
read_and_process (off_t size, int (*processor) (size_t, char *))
{
union block *data_block;
size_t data_size;
if (multi_volume_option)
save_sizeleft = size;
while (size)
{
data_block = find_next_block ();
if (! data_block)
{
ERROR ((0, 0, _("Unexpected EOF in archive")));
return;
}
data_size = available_space_after (data_block);
if (data_size > size)
data_size = size;
if (!(*processor) (data_size, data_block->buffer))
processor = process_noop;
set_next_block_after ((union block *)
(data_block->buffer + data_size - 1));
size -= data_size;
if (multi_volume_option)
save_sizeleft -= data_size;
}
}
static void
fill_in_sparse_array (void)
{
int counter;
sp_array_size = 10;
sparsearray = xmalloc (sp_array_size * sizeof (struct sp_array));
for (counter = 0; counter < SPARSES_IN_OLDGNU_HEADER; counter++)
{
if (current_header->oldgnu_header.sp[counter].numbytes == 0)
break;
sparsearray[counter].offset =
OFF_FROM_HEADER (current_header->oldgnu_header.sp[counter].offset);
sparsearray[counter].numbytes =
SIZE_FROM_HEADER (current_header->oldgnu_header.sp[counter].numbytes);
}
if (current_header->oldgnu_header.isextended)
{
static int so_far_ind = SPARSES_IN_OLDGNU_HEADER;
union block *exhdr;
while (1)
{
exhdr = find_next_block ();
if (!exhdr)
FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
for (counter = 0; counter < SPARSES_IN_SPARSE_HEADER; counter++)
{
if (counter + so_far_ind > sp_array_size - 1)
{
sp_array_size *= 2;
sparsearray =
xrealloc (sparsearray,
sp_array_size * sizeof (struct sp_array));
}
sparsearray[counter + so_far_ind].offset =
OFF_FROM_HEADER (exhdr->sparse_header.sp[counter].offset);
sparsearray[counter + so_far_ind].numbytes =
SIZE_FROM_HEADER (exhdr->sparse_header.sp[counter].numbytes);
}
if (!exhdr->sparse_header.isextended)
break;
so_far_ind += SPARSES_IN_SPARSE_HEADER;
set_next_block_after (exhdr);
}
set_next_block_after (exhdr);
}
}
static void
diff_sparse_files (off_t size_of_file)
{
off_t remaining_size = size_of_file;
char *buffer = xmalloc (BLOCKSIZE * sizeof (char));
size_t buffer_size = BLOCKSIZE;
union block *data_block = 0;
int counter = 0;
int different = 0;
fill_in_sparse_array ();
while (remaining_size > 0)
{
ssize_t status;
size_t chunk_size;
off_t offset;
#if 0
off_t amount_read = 0;
#endif
data_block = find_next_block ();
if (!data_block)
FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
chunk_size = sparsearray[counter].numbytes;
if (!chunk_size)
break;
offset = sparsearray[counter].offset;
if (lseek (diff_handle, offset, SEEK_SET) < 0)
{
seek_error_details (current_file_name, offset);
report_difference (0);
}
while (buffer_size < chunk_size)
{
if (buffer_size * 2 < buffer_size)
xalloc_die ();
buffer_size *= 2;
buffer = xrealloc (buffer, buffer_size * sizeof (char));
}
while (chunk_size > BLOCKSIZE)
{
if (status = safe_read (diff_handle, buffer, BLOCKSIZE),
status != BLOCKSIZE)
{
if (status < 0)
{
read_error (current_file_name);
report_difference (0);
}
else
{
char message[MESSAGE_BUFFER_SIZE];
sprintf (message, _("Could only read %lu of %lu bytes"),
(unsigned long) status, (unsigned long) chunk_size);
report_difference (message);
}
break;
}
if (memcmp (buffer, data_block->buffer, BLOCKSIZE))
{
different = 1;
break;
}
chunk_size -= status;
remaining_size -= status;
set_next_block_after (data_block);
data_block = find_next_block ();
if (!data_block)
FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
}
if (status = safe_read (diff_handle, buffer, chunk_size),
status != chunk_size)
{
if (status < 0)
{
read_error (current_file_name);
report_difference (0);
}
else
{
char message[MESSAGE_BUFFER_SIZE];
sprintf (message, _("Could only read %lu of %lu bytes"),
(unsigned long) status, (unsigned long) chunk_size);
report_difference (message);
}
break;
}
if (memcmp (buffer, data_block->buffer, chunk_size))
{
different = 1;
break;
}
#if 0
amount_read += chunk_size;
if (amount_read >= BLOCKSIZE)
{
amount_read = 0;
set_next_block_after (data_block);
data_block = find_next_block ();
if (!data_block)
FATAL_ERROR ((0, 0, _("Unexpected EOF in archive")));
}
#endif
set_next_block_after (data_block);
counter++;
remaining_size -= chunk_size;
}
#if 0
if (amount_read != size_of_file)
different = 1;
#endif
set_next_block_after (data_block);
free (sparsearray);
if (different)
report_difference (_("Contents differ"));
}
static int
get_stat_data (char const *file_name, struct stat *stat_data)
{
int status = deref_stat (dereference_option, file_name, stat_data);
if (status != 0)
{
if (errno == ENOENT)
stat_warn (file_name);
else
stat_error (file_name);
report_difference (0);
return 0;
}
return 1;
}
void
diff_archive (void)
{
struct stat stat_data;
size_t name_length;
int status;
struct utimbuf restore_times;
set_next_block_after (current_header);
decode_header (current_header, ¤t_stat, ¤t_format, 1);
if (verbose_option)
{
if (now_verifying)
fprintf (stdlis, _("Verify "));
print_header ();
}
switch (current_header->header.typeflag)
{
default:
ERROR ((0, 0, _("%s: Unknown file type '%c', diffed as normal file"),
quotearg_colon (current_file_name),
current_header->header.typeflag));
case AREGTYPE:
case REGTYPE:
case GNUTYPE_SPARSE:
case CONTTYPE:
name_length = strlen (current_file_name) - 1;
if (ISSLASH (current_file_name[name_length]))
goto really_dir;
if (!get_stat_data (current_file_name, &stat_data))
{
skip_member ();
goto quit;
}
if (!S_ISREG (stat_data.st_mode))
{
report_difference (_("File type differs"));
skip_member ();
goto quit;
}
if ((current_stat.st_mode & MODE_ALL) != (stat_data.st_mode & MODE_ALL))
report_difference (_("Mode differs"));
#if !MSDOS
if (stat_data.st_uid != current_stat.st_uid)
report_difference (_("Uid differs"));
if (stat_data.st_gid != current_stat.st_gid)
report_difference (_("Gid differs"));
#endif
if (stat_data.st_mtime != current_stat.st_mtime)
report_difference (_("Mod time differs"));
if (current_header->header.typeflag != GNUTYPE_SPARSE &&
stat_data.st_size != current_stat.st_size)
{
report_difference (_("Size differs"));
skip_member ();
goto quit;
}
diff_handle = open (current_file_name, O_RDONLY | O_BINARY);
if (diff_handle < 0)
{
open_error (current_file_name);
skip_member ();
report_difference (0);
goto quit;
}
restore_times.actime = stat_data.st_atime;
restore_times.modtime = stat_data.st_mtime;
if (current_header->header.typeflag == GNUTYPE_SPARSE)
diff_sparse_files (current_stat.st_size);
else
{
if (multi_volume_option)
{
assign_string (&save_name, current_file_name);
save_totsize = current_stat.st_size;
}
read_and_process (current_stat.st_size, process_rawdata);
if (multi_volume_option)
assign_string (&save_name, 0);
}
status = close (diff_handle);
if (status != 0)
close_error (current_file_name);
if (atime_preserve_option)
utime (current_file_name, &restore_times);
quit:
break;
#if !MSDOS
case LNKTYPE:
{
struct stat link_data;
if (!get_stat_data (current_file_name, &stat_data))
break;
if (!get_stat_data (current_link_name, &link_data))
break;
if (stat_data.st_dev != link_data.st_dev
|| stat_data.st_ino != link_data.st_ino)
{
char *message =
xmalloc (MESSAGE_BUFFER_SIZE + 4 * strlen (current_link_name));
sprintf (message, _("Not linked to %s"),
quote (current_link_name));
report_difference (message);
free (message);
break;
}
break;
}
#endif
#ifdef HAVE_READLINK
case SYMTYPE:
{
size_t len = strlen (current_link_name);
char *linkbuf = alloca (len + 1);
status = readlink (current_file_name, linkbuf, len + 1);
if (status < 0)
{
if (errno == ENOENT)
readlink_warn (current_file_name);
else
readlink_error (current_file_name);
report_difference (0);
}
else if (status != len
|| strncmp (current_link_name, linkbuf, len) != 0)
report_difference (_("Symlink differs"));
break;
}
#endif
case CHRTYPE:
case BLKTYPE:
case FIFOTYPE:
if (!get_stat_data (current_file_name, &stat_data))
break;
if (current_header->header.typeflag == CHRTYPE
? !S_ISCHR (stat_data.st_mode)
: current_header->header.typeflag == BLKTYPE
? !S_ISBLK (stat_data.st_mode)
:
!S_ISFIFO (stat_data.st_mode))
{
report_difference (_("File type differs"));
break;
}
if ((current_header->header.typeflag == CHRTYPE
|| current_header->header.typeflag == BLKTYPE)
&& current_stat.st_rdev != stat_data.st_rdev)
{
report_difference (_("Device number differs"));
break;
}
if ((current_stat.st_mode & MODE_ALL) != (stat_data.st_mode & MODE_ALL))
{
report_difference (_("Mode differs"));
break;
}
break;
case GNUTYPE_DUMPDIR:
{
char *dumpdir_buffer = get_directory_contents (current_file_name, 0);
if (multi_volume_option)
{
assign_string (&save_name, current_file_name);
save_totsize = current_stat.st_size;
}
if (dumpdir_buffer)
{
dumpdir_cursor = dumpdir_buffer;
read_and_process (current_stat.st_size, process_dumpdir);
free (dumpdir_buffer);
}
else
read_and_process (current_stat.st_size, process_noop);
if (multi_volume_option)
assign_string (&save_name, 0);
}
case DIRTYPE:
name_length = strlen (current_file_name) - 1;
really_dir:
while (name_length && ISSLASH (current_file_name[name_length]))
current_file_name[name_length--] = '\0';
if (!get_stat_data (current_file_name, &stat_data))
break;
if (!S_ISDIR (stat_data.st_mode))
{
report_difference (_("File type differs"));
break;
}
if ((current_stat.st_mode & MODE_ALL) != (stat_data.st_mode & MODE_ALL))
{
report_difference (_("Mode differs"));
break;
}
break;
case GNUTYPE_VOLHDR:
break;
case GNUTYPE_MULTIVOL:
{
off_t offset;
name_length = strlen (current_file_name) - 1;
if (ISSLASH (current_file_name[name_length]))
goto really_dir;
if (!get_stat_data (current_file_name, &stat_data))
break;
if (!S_ISREG (stat_data.st_mode))
{
report_difference (_("File type differs"));
skip_member ();
break;
}
offset = OFF_FROM_HEADER (current_header->oldgnu_header.offset);
if (stat_data.st_size != current_stat.st_size + offset)
{
report_difference (_("Size differs"));
skip_member ();
break;
}
diff_handle = open (current_file_name, O_RDONLY | O_BINARY);
if (diff_handle < 0)
{
open_error (current_file_name);
report_difference (0);
skip_member ();
break;
}
if (lseek (diff_handle, offset, SEEK_SET) < 0)
{
seek_error_details (current_file_name, offset);
report_difference (0);
break;
}
if (multi_volume_option)
{
assign_string (&save_name, current_file_name);
save_totsize = stat_data.st_size;
}
read_and_process (current_stat.st_size, process_rawdata);
if (multi_volume_option)
assign_string (&save_name, 0);
status = close (diff_handle);
if (status != 0)
close_error (current_file_name);
break;
}
}
}
void
verify_volume (void)
{
if (!diff_buffer)
diff_init ();
#if HAVE_FSYNC
fsync (archive);
#endif
#ifdef FDFLUSH
ioctl (archive, FDFLUSH);
#endif
#ifdef MTIOCTOP
{
struct mtop operation;
int status;
operation.mt_op = MTBSF;
operation.mt_count = 1;
if (status = rmtioctl (archive, MTIOCTOP, (char *) &operation), status < 0)
{
if (errno != EIO
|| (status = rmtioctl (archive, MTIOCTOP, (char *) &operation),
status < 0))
{
#endif
if (rmtlseek (archive, (off_t) 0, SEEK_SET) != 0)
{
seek_warn (archive_name_array[0]);
return;
}
#ifdef MTIOCTOP
}
}
}
#endif
access_mode = ACCESS_READ;
now_verifying = 1;
flush_read ();
while (1)
{
enum read_header status = read_header (0);
if (status == HEADER_FAILURE)
{
int counter = 0;
while (status == HEADER_FAILURE);
{
counter++;
status = read_header (0);
}
ERROR ((0, 0,
_("VERIFY FAILURE: %d invalid header(s) detected"), counter));
}
if (status == HEADER_ZERO_BLOCK || status == HEADER_END_OF_FILE)
break;
diff_archive ();
}
access_mode = ACCESS_WRITE;
now_verifying = 0;
}