GNU tar 1.12

src/compare.c

@@ -0,0 +1,874 @@
+/* Diff files from a tar archive.
+   Copyright (C) 1988, 92, 93, 94, 96, 97 Free Software Foundation, Inc.
+   Written by John Gilmore, on 1987-04-30.
+
+   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
+   version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+   Public License for more details.
+
+   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.  */
+
+#include "system.h"
+
+#if HAVE_LINUX_FD_H
+# include <linux/fd.h>
+#endif
+
+#include "common.h"
+#include "rmt.h"
+
+/* Spare space for messages, hopefully safe even after gettext.  */
+#define MESSAGE_BUFFER_SIZE 100
+
+/* Nonzero if we are verifying at the moment.  */
+int now_verifying = 0;
+
+/* File descriptor for the file we are diffing.  */
+static int diff_handle;
+
+/* Area for reading file contents into.  */
+static char *diff_buffer = NULL;
+
+/*--------------------------------.
+| Initialize for a diff operation |
+`--------------------------------*/
+
+void
+diff_init (void)
+{
+  diff_buffer = (char *) valloc ((unsigned) record_size);
+  if (!diff_buffer)
+    FATAL_ERROR ((0, 0,
+		  _("Could not allocate memory for diff buffer of %d bytes"),
+		  record_size));
+}
+
+/*------------------------------------------------------------------------.
+| Sigh about something that differs by writing a MESSAGE to stdlis, given |
+| MESSAGE is not NULL.  Also set the exit status if not already.          |
+`------------------------------------------------------------------------*/
+
+static void
+report_difference (const char *message)
+{
+  if (message)
+    fprintf (stdlis, "%s: %s\n", current_file_name, message);
+
+  if (exit_status == TAREXIT_SUCCESS)
+    exit_status = TAREXIT_DIFFERS;
+}
+
+/*-----------------------------------------------------------------------.
+| Takes a buffer returned by read_and_process and does nothing with it.	 |
+`-----------------------------------------------------------------------*/
+
+/* Yes, I know.  SIZE and DATA are unused in this function.  Some compilers
+   may even report it.  That's OK, just relax!  */
+
+static int
+process_noop (long size, char *data)
+{
+  return 1;
+}
+
+/*---.
+| ?  |
+`---*/
+
+static int
+process_rawdata (long bytes, char *buffer)
+{
+  int status = read (diff_handle, diff_buffer, (size_t) bytes);
+  char message[MESSAGE_BUFFER_SIZE];
+
+  if (status != bytes)
+    {
+      if (status < 0)
+	{
+	  WARN ((0, errno, _("Cannot read %s"), current_file_name));
+	  report_difference (NULL);
+	}
+      else
+	{
+	  sprintf (message, _("Could only read %d of %ld bytes"),
+		   status, bytes);
+	  report_difference (message);
+	}
+      return 0;
+    }
+
+  if (memcmp (buffer, diff_buffer, (size_t) bytes))
+    {
+      report_difference (_("Data differs"));
+      return 0;
+    }
+
+  return 1;
+}
+
+/*---.
+| ?  |
+`---*/
+
+/* Directory contents, only for GNUTYPE_DUMPDIR.  */
+
+static char *dumpdir_cursor;
+
+static int
+process_dumpdir (long bytes, char *buffer)
+{
+  if (memcmp (buffer, dumpdir_cursor, (size_t) bytes))
+    {
+      report_difference (_("Data differs"));
+      return 0;
+    }
+
+  dumpdir_cursor += bytes;
+  return 1;
+}
+
+/*------------------------------------------------------------------------.
+| Some other routine wants SIZE bytes in the archive.  For each chunk of  |
+| the archive, call PROCESSOR with the size of the chunk, and the address |
+| of the chunk it can work with.  The PROCESSOR should return nonzero for |
+| success.  It it return error once, continue skipping without calling    |
+| PROCESSOR anymore.                                                      |
+`------------------------------------------------------------------------*/
+
+static void
+read_and_process (long size, int (*processor) (long, char *))
+{
+  union block *data_block;
+  long data_size;
+
+  if (multi_volume_option)
+    save_sizeleft = size;
+  while (size)
+    {
+      data_block = find_next_block ();
+      if (data_block == NULL)
+	{
+	  ERROR ((0, 0, _("Unexpected EOF on archive file")));
+	  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;
+    }
+}
+
+/*---.
+| ?  |
+`---*/
+
+/* JK This routine should be used more often than it is ... look into
+   that.  Anyhow, what it does is translate the sparse information on the
+   header, and in any subsequent extended headers, into an array of
+   structures with true numbers, as opposed to character strings.  It
+   simply makes our life much easier, doing so many comparisong and such.
+   */
+
+static void
+fill_in_sparse_array (void)
+{
+  int counter;
+
+  /* Allocate space for our scratch space; it's initially 10 elements
+     long, but can change in this routine if necessary.  */
+
+  sp_array_size = 10;
+  sparsearray = (struct sp_array *) xmalloc (sp_array_size * sizeof (struct sp_array));
+
+  /* There are at most five of these structures in the header itself;
+     read these in first.  */
+
+  for (counter = 0; counter < SPARSES_IN_OLDGNU_HEADER; counter++)
+    {
+      /* Compare to 0, or use !(int)..., for Pyramid's dumb compiler.  */
+      if (current_header->oldgnu_header.sp[counter].numbytes == 0)
+	break;
+
+      sparsearray[counter].offset =
+	from_oct (1 + 12, current_header->oldgnu_header.sp[counter].offset);
+      sparsearray[counter].numbytes =
+	from_oct (1 + 12, current_header->oldgnu_header.sp[counter].numbytes);
+    }
+
+  /* If the header's extended, we gotta read in exhdr's till we're done.  */
+
+  if (current_header->oldgnu_header.isextended)
+    {
+      /* How far into the sparsearray we are `so far'.  */
+      static int so_far_ind = SPARSES_IN_OLDGNU_HEADER;
+      union block *exhdr;
+
+      while (1)
+	{
+	  exhdr = find_next_block ();
+	  for (counter = 0; counter < SPARSES_IN_SPARSE_HEADER; counter++)
+	    {
+	      if (counter + so_far_ind > sp_array_size - 1)
+		{
+		  /* We just ran out of room in our scratch area -
+		     realloc it.  */
+
+		  sp_array_size *= 2;
+		  sparsearray = (struct sp_array *)
+		    xrealloc (sparsearray,
+			      sp_array_size * sizeof (struct sp_array));
+		}
+
+	      /* Convert the character strings into longs.  */
+
+	      sparsearray[counter + so_far_ind].offset =
+		from_oct (1 + 12, exhdr->sparse_header.sp[counter].offset);
+	      sparsearray[counter + so_far_ind].numbytes =
+		from_oct (1 + 12, exhdr->sparse_header.sp[counter].numbytes);
+	    }
+
+	  /* If this is the last extended header for this file, we can
+	     stop.  */
+
+	  if (!exhdr->sparse_header.isextended)
+	    break;
+
+	  so_far_ind += SPARSES_IN_SPARSE_HEADER;
+	  set_next_block_after (exhdr);
+	}
+
+      /* Be sure to skip past the last one.  */
+
+      set_next_block_after (exhdr);
+    }
+}
+
+/*---.
+| ?  |
+`---*/
+
+/* JK Diff'ing a sparse file with its counterpart on the tar file is a
+   bit of a different story than a normal file.  First, we must know what
+   areas of the file to skip through, i.e., we need to contruct a
+   sparsearray, which will hold all the information we need.  We must
+   compare small amounts of data at a time as we find it.  */
+
+/* FIXME: This does not look very solid to me, at first glance.  Zero areas
+   are not checked, spurious sparse entries seemingly goes undetected, and
+   I'm not sure overall identical sparsity is verified.  */
+
+static void
+diff_sparse_files (int size_of_file)
+{
+  int remaining_size = size_of_file;
+  char *buffer = (char *) xmalloc (BLOCKSIZE * sizeof (char));
+  int buffer_size = BLOCKSIZE;
+  union block *data_block = NULL;
+  int counter = 0;
+  int different = 0;
+
+  fill_in_sparse_array ();
+
+  while (remaining_size > 0)
+    {
+      int status;
+      long chunk_size;
+#if 0
+      int amount_read = 0;
+#endif
+
+      data_block = find_next_block ();
+      chunk_size = sparsearray[counter].numbytes;
+      if (!chunk_size)
+	break;
+
+      lseek (diff_handle, sparsearray[counter].offset, 0);
+
+      /* Take care to not run out of room in our buffer.  */
+
+      while (buffer_size < chunk_size)
+	{
+	  buffer_size *= 2;
+	  buffer = (char *) xrealloc (buffer, buffer_size * sizeof (char));
+	}
+
+      while (chunk_size > BLOCKSIZE)
+	{
+	  if (status = read (diff_handle, buffer, BLOCKSIZE),
+	      status != BLOCKSIZE)
+	    {
+	      if (status < 0)
+		{
+		  WARN ((0, errno, _("Cannot read %s"), current_file_name));
+		  report_difference (NULL);
+		}
+	      else
+		{
+		  char message[MESSAGE_BUFFER_SIZE];
+
+		  sprintf (message, _("Could only read %d of %ld bytes"),
+			   status, 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 (status = read (diff_handle, buffer, (size_t) chunk_size),
+	  status != chunk_size)
+	{
+	  if (status < 0)
+	    {
+	      WARN ((0, errno, _("Cannot read %s"), current_file_name));
+	      report_difference (NULL);
+	    }
+	  else
+	    {
+	      char message[MESSAGE_BUFFER_SIZE];
+
+	      sprintf (message, _("Could only read %d of %ld bytes"),
+		       status, chunk_size);
+	      report_difference (message);
+	    }
+	  break;
+	}
+
+      if (memcmp (buffer, data_block->buffer, (size_t) 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 ();
+	}
+#endif
+      set_next_block_after (data_block);
+      counter++;
+      remaining_size -= chunk_size;
+    }
+
+#if 0
+  /* If the number of bytes read isn't the number of bytes supposedly in
+     the file, they're different.  */
+
+  if (amount_read != size_of_file)
+    different = 1;
+#endif
+
+  set_next_block_after (data_block);
+  free (sparsearray);
+
+  if (different)
+    report_difference (_("Data differs"));
+}
+
+/*---------------------------------------------------------------------.
+| Call either stat or lstat over STAT_DATA, depending on --dereference |
+| (-h), for a file which should exist.  Diagnose any problem.  Return  |
+| nonzero for success, zero otherwise.				       |
+`---------------------------------------------------------------------*/
+
+static int
+get_stat_data (struct stat *stat_data)
+{
+  int status = (dereference_option
+		? stat (current_file_name, stat_data)
+		: lstat (current_file_name, stat_data));
+
+  if (status < 0)
+    {
+      if (errno == ENOENT)
+	report_difference (_("File does not exist"));
+      else
+	{
+	  ERROR ((0, errno, _("Cannot stat file %s"), current_file_name));
+	  report_difference (NULL);
+	}
+#if 0
+      skip_file ((long) current_stat.st_size);
+#endif
+      return 0;
+    }
+
+  return 1;
+}
+
+/*----------------------------------.
+| Diff a file against the archive.  |
+`----------------------------------*/
+
+void
+diff_archive (void)
+{
+  struct stat stat_data;
+  int name_length;
+  int status;
+
+  errno = EPIPE;		/* FIXME: errno should be read-only */
+				/* FIXME: remove perrors */
+
+  set_next_block_after (current_header);
+  decode_header (current_header, &current_stat, &current_format, 1);
+
+  /* Print the block from `current_header' and `current_stat'.  */
+
+  if (verbose_option)
+    {
+      if (now_verifying)
+	fprintf (stdlis, _("Verify "));
+      print_header ();
+    }
+
+  switch (current_header->header.typeflag)
+    {
+    default:
+      WARN ((0, 0, _("Unknown file type '%c' for %s, diffed as normal file"),
+		 current_header->header.typeflag, current_file_name));
+      /* Fall through.  */
+
+    case AREGTYPE:
+    case REGTYPE:
+    case GNUTYPE_SPARSE:
+    case CONTTYPE:
+
+      /* Appears to be a file.  See if it's really a directory.  */
+
+      name_length = strlen (current_file_name) - 1;
+      if (current_file_name[name_length] == '/')
+	goto really_dir;
+
+      if (!get_stat_data (&stat_data))
+	{
+	  if (current_header->oldgnu_header.isextended)
+	    skip_extended_headers ();
+	  skip_file ((long) current_stat.st_size);
+	  goto quit;
+	}
+
+      if (!S_ISREG (stat_data.st_mode))
+	{
+	  report_difference (_("Not a regular file"));
+	  skip_file ((long) current_stat.st_size);
+	  goto quit;
+	}
+
+      stat_data.st_mode &= 07777;
+      if (stat_data.st_mode != current_stat.st_mode)
+	report_difference (_("Mode differs"));
+
+#if !MSDOS
+      /* stat() in djgpp's C library gives a constant number of 42 as the
+	 uid and gid of a file.  So, comparing an FTP'ed archive just after
+	 unpack would fail on 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_file ((long) current_stat.st_size);
+	  goto quit;
+	}
+
+      diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY);
+
+      if (diff_handle < 0 && !absolute_names_option)
+	{
+	  char *tmpbuf = xmalloc (strlen (current_file_name) + 2);
+
+	  *tmpbuf = '/';
+	  strcpy (tmpbuf + 1, current_file_name);
+	  diff_handle = open (tmpbuf, O_NDELAY | O_RDONLY);
+	  free (tmpbuf);
+	}
+      if (diff_handle < 0)
+	{
+	  ERROR ((0, errno, _("Cannot open %s"), current_file_name));
+	  if (current_header->oldgnu_header.isextended)
+	    skip_extended_headers ();
+	  skip_file ((long) current_stat.st_size);
+	  report_difference (NULL);
+	  goto quit;
+	}
+
+      /* Need to treat sparse files completely differently here.  */
+
+      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;
+	      /* save_sizeleft is set in read_and_process.  */
+	    }
+
+	  read_and_process ((long) (current_stat.st_size), process_rawdata);
+
+	  if (multi_volume_option)
+	    assign_string (&save_name, NULL);
+	}
+
+      status = close (diff_handle);
+      if (status < 0)
+	ERROR ((0, errno, _("Error while closing %s"), current_file_name));
+
+    quit:
+      break;
+
+#if !MSDOS
+    case LNKTYPE:
+      {
+	dev_t dev;
+	ino_t ino;
+
+	if (!get_stat_data (&stat_data))
+	  break;
+
+	dev = stat_data.st_dev;
+	ino = stat_data.st_ino;
+	status = stat (current_link_name, &stat_data);
+	if (status < 0)
+	  {
+	    if (errno == ENOENT)
+	      report_difference (_("Does not exist"));
+	    else
+	      {
+		WARN ((0, errno, _("Cannot stat file %s"), current_file_name));
+		report_difference (NULL);
+	      }
+	    break;
+	  }
+
+	if (stat_data.st_dev != dev || stat_data.st_ino != ino)
+	  {
+	    char *message = (char *)
+	      xmalloc (MESSAGE_BUFFER_SIZE + strlen (current_link_name));
+
+	    sprintf (message, _("Not linked to %s"), current_link_name);
+	    report_difference (message);
+	    free (message);
+	    break;
+	  }
+
+	break;
+      }
+#endif /* not MSDOS */
+
+#ifdef S_ISLNK
+    case SYMTYPE:
+      {
+	char linkbuf[NAME_FIELD_SIZE + 3]; /* FIXME: may be too short.  */
+
+	status = readlink (current_file_name, linkbuf, (sizeof linkbuf) - 1);
+
+	if (status < 0)
+	  {
+	    if (errno == ENOENT)
+	      report_difference (_("No such file or directory"));
+	    else
+	      {
+		WARN ((0, errno, _("Cannot read link %s"), current_file_name));
+		report_difference (NULL);
+	      }
+	    break;
+	  }
+
+	linkbuf[status] = '\0';	/* null-terminate it */
+	if (strncmp (current_link_name, linkbuf, (size_t) status) != 0)
+	  report_difference (_("Symlink differs"));
+
+	break;
+      }
+#endif /* not S_ISLNK */
+
+#ifdef S_IFCHR
+    case CHRTYPE:
+      current_stat.st_mode |= S_IFCHR;
+      goto check_node;
+#endif /* not S_IFCHR */
+
+#ifdef S_IFBLK
+      /* If local system doesn't support block devices, use default case.  */
+
+    case BLKTYPE:
+      current_stat.st_mode |= S_IFBLK;
+      goto check_node;
+#endif /* not S_IFBLK */
+
+#ifdef S_ISFIFO
+      /* If local system doesn't support FIFOs, use default case.  */
+
+    case FIFOTYPE:
+# ifdef S_IFIFO
+      current_stat.st_mode |= S_IFIFO;
+# endif
+      current_stat.st_rdev = 0;	/* FIXME: do we need this? */
+      goto check_node;
+#endif /* S_ISFIFO */
+
+    check_node:
+      /* FIXME: deal with umask.  */
+
+      if (!get_stat_data (&stat_data))
+	break;
+
+      if (current_stat.st_rdev != stat_data.st_rdev)
+	{
+	  report_difference (_("Device numbers changed"));
+	  break;
+	}
+
+      if (
+#ifdef S_IFMT
+	  current_stat.st_mode != stat_data.st_mode
+#else
+	  /* POSIX lossage.  */
+	  (current_stat.st_mode & 07777) != (stat_data.st_mode & 07777)
+#endif
+	  )
+	{
+	  report_difference (_("Mode or device-type changed"));
+	  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;
+	    /* save_sizeleft is set in read_and_process.  */
+	  }
+
+	if (dumpdir_buffer)
+	  {
+	    dumpdir_cursor = dumpdir_buffer;
+	    read_and_process ((long) (current_stat.st_size), process_dumpdir);
+	    free (dumpdir_buffer);
+	  }
+	else
+	  read_and_process ((long) (current_stat.st_size), process_noop);
+
+	if (multi_volume_option)
+	  assign_string (&save_name, NULL);
+	/* Fall through.  */
+      }
+
+    case DIRTYPE:
+      /* Check for trailing /.  */
+
+      name_length = strlen (current_file_name) - 1;
+
+    really_dir:
+      while (name_length && current_file_name[name_length] == '/')
+	current_file_name[name_length--] = '\0';	/* zap / */
+
+      if (!get_stat_data (&stat_data))
+	break;
+
+      if (!S_ISDIR (stat_data.st_mode))
+	{
+	  report_difference (_("No longer a directory"));
+	  break;
+	}
+
+      if ((stat_data.st_mode & 07777) != (current_stat.st_mode & 07777))
+	report_difference (_("Mode differs"));
+      break;
+
+    case GNUTYPE_VOLHDR:
+      break;
+
+    case GNUTYPE_MULTIVOL:
+      {
+	off_t offset;
+
+	name_length = strlen (current_file_name) - 1;
+	if (current_file_name[name_length] == '/')
+	  goto really_dir;
+
+	if (!get_stat_data (&stat_data))
+	  break;
+
+	if (!S_ISREG (stat_data.st_mode))
+	  {
+	    report_difference (_("Not a regular file"));
+	    skip_file ((long) current_stat.st_size);
+	    break;
+	  }
+
+	stat_data.st_mode &= 07777;
+	offset = from_oct (1 + 12, current_header->oldgnu_header.offset);
+	if (stat_data.st_size != current_stat.st_size + offset)
+	  {
+	    report_difference (_("Size differs"));
+	    skip_file ((long) current_stat.st_size);
+	    break;
+	  }
+
+	diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY);
+
+	if (diff_handle < 0)
+	  {
+	    WARN ((0, errno, _("Cannot open file %s"), current_file_name));
+	    report_difference (NULL);
+	    skip_file ((long) current_stat.st_size);
+	    break;
+	  }
+
+	status = lseek (diff_handle, offset, 0);
+	if (status != offset)
+	  {
+	    WARN ((0, errno, _("Cannot seek to %ld in file %s"),
+		   offset, current_file_name));
+	    report_difference (NULL);
+	    break;
+	  }
+
+	if (multi_volume_option)
+	  {
+	    assign_string (&save_name, current_file_name);
+	    save_totsize = stat_data.st_size;
+	    /* save_sizeleft is set in read_and_process.  */
+	  }
+
+	read_and_process ((long) (current_stat.st_size), process_rawdata);
+
+	if (multi_volume_option)
+	  assign_string (&save_name, NULL);
+
+	status = close (diff_handle);
+	if (status < 0)
+	  ERROR ((0, errno, _("Error while closing %s"), current_file_name));
+
+	break;
+      }
+    }
+}
+
+/*---.
+| ?  |
+`---*/
+
+void
+verify_volume (void)
+{
+  if (!diff_buffer)
+    diff_init ();
+
+  /* Verifying an archive is meant to check if the physical media got it
+     correctly, so try to defeat clever in-memory buffering pertaining to
+     this particular media.  On Linux, for example, the floppy drive would
+     not even be accessed for the whole verification.
+
+     The code was using fsync only when the ioctl is unavailable, but
+     Marty Leisner says that the ioctl does not work when not preceded by
+     fsync.  So, until we know better, or maybe to please Marty, let's do it
+     the unbelievable way :-).  */
+
+#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, 0L, 0) != 0)
+	      {
+		/* Lseek failed.  Try a different method.  */
+
+		WARN ((0, errno,
+		       _("Could not rewind archive file for verify")));
+		return;
+	      }
+#ifdef MTIOCTOP
+	  }
+      }
+  }
+#endif
+
+  access_mode = ACCESS_READ;
+  now_verifying = 1;
+
+  flush_read ();
+  while (1)
+    {
+      enum read_header status = read_header ();
+
+      if (status == HEADER_FAILURE)
+	{
+	  int counter = 0;
+
+	  while (status == HEADER_FAILURE);
+	    {
+	      counter++;
+	      status = read_header ();
+	    }
+	  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;
+}

src/open3.c

@@ -0,0 +1,178 @@
+/* Defines for Sys V style 3-argument open call.
+   Copyright (C) 1988, 1994, 1995, 1996 Free Software Foundation, Inc.
+
+   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
+   version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+   Public License for more details.
+
+   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.  */
+
+#include "system.h"
+
+#if EMUL_OPEN3
+
+/* open3.h -- #defines for the various flags for the Sys V style 3-argument
+   open() call.  On BSD or System 5, the system already has this in an
+   include file.  This file is needed for V7 and MINIX systems for the
+   benefit of open3() in port.c, a routine that emulates the 3-argument call
+   using system calls available on V7/MINIX.
+
+   Written 1987-06-10 by Richard Todd.
+
+   The names have been changed by John Gilmore, 1987-07-31, since Richard
+   called it "bsdopen", and really this change was introduced in AT&T Unix
+   systems before BSD picked it up.  */
+
+/*-----------------------------------------------------------------------.
+| open3 -- routine to emulate the 3-argument open system.		 |
+| 									 |
+| open3 (path, flag, mode);						 |
+| 									 |
+| Attempts to open the file specified by the given pathname.  The	 |
+| following flag bits specify options to the routine.  Needless to say,	 |
+| you should only specify one of the first three.  Function returns file |
+| descriptor if successful, -1 and errno if not.			 |
+`-----------------------------------------------------------------------*/
+
+/* The routine obeys the following mode arguments:
+
+   O_RDONLY	file open for read only
+   O_WRONLY	file open for write only
+   O_RDWR	file open for both read & write
+
+   O_CREAT	file is created with specified mode if it needs to be
+   O_TRUNC	if file exists, it is truncated to 0 bytes
+   O_EXCL	used with O_CREAT--routine returns error if file exists  */
+
+/* Call that if present in most modern Unix systems.  This version attempts
+   to support all the flag bits except for O_NDELAY and O_APPEND, which are
+   silently ignored.  The emulation is not as efficient as the real thing
+   (at worst, 4 system calls instead of one), but there's not much I can do
+   about that.  */
+
+/* Array to give arguments to access for various modes FIXME, this table
+   depends on the specific integer values of O_*, and also contains
+   integers (args to 'access') that should be #define's.  */
+
+static int modes[] =
+  {
+    04,				/* O_RDONLY */
+    02,				/* O_WRONLY */
+    06,				/* O_RDWR */
+    06,				/* invalid, just cope: O_WRONLY+O_RDWR */
+  };
+
+/* Shut off the automatic emulation of open(), we'll need it. */
+#undef open
+
+int
+open3 (char *path, int flags, int mode)
+{
+  int exists = 1;
+  int call_creat = 0;
+
+  /* We actually do the work by calling the open() or creat() system
+     call, depending on the flags.  Call_creat is true if we will use
+     creat(), false if we will use open().  */
+
+  /* See if the file exists and is accessible in the requested mode.
+
+     Strictly speaking we shouldn't be using access, since access checks
+     against real uid, and the open call should check against euid.  Most
+     cases real uid == euid, so it won't matter.  FIXME.  FIXME, the
+     construction "flags & 3" and the modes table depends on the specific
+     integer values of the O_* #define's.  Foo!  */
+
+  if (access (path, modes[flags & 3]) < 0)
+    {
+      if (errno == ENOENT)
+	{
+	  /* The file does not exist.  */
+
+	  exists = 0;
+	}
+      else
+	{
+	  /* Probably permission violation.  */
+
+	  if (flags & O_EXCL)
+	    {
+	      /* Oops, the file exists, we didn't want it.  No matter
+		 what the error, claim EEXIST.  */
+
+	      errno = EEXIST;	/* FIXME: errno should be read-only */
+	    }
+	  return -1;
+	}
+    }
+
+  /* If we have the O_CREAT bit set, check for O_EXCL.  */
+
+  if (flags & O_CREAT)
+    {
+      if ((flags & O_EXCL) && exists)
+	{
+	  /* Oops, the file exists and we didn't want it to.  */
+
+	  errno = EEXIST;	/* FIXME: errno should be read-only */
+	  return -1;
+	}
+
+      /* If the file doesn't exist, be sure to call creat() so that it
+	 will be created with the proper mode.  */
+
+      if (!exists)
+	call_creat = 1;
+    }
+  else
+    {
+      /* If O_CREAT isn't set and the file doesn't exist, error.  */
+
+      if (!exists)
+	{
+	  errno = ENOENT;	/* FIXME: errno should be read-only */
+	  return -1;
+	}
+    }
+
+  /* If the O_TRUNC flag is set and the file exists, we want to call
+     creat() anyway, since creat() guarantees that the file will be
+     truncated and open()-for-writing doesn't.  (If the file doesn't
+     exist, we're calling creat() anyway and the file will be created
+     with zero length.)  */
+
+  if ((flags & O_TRUNC) && exists)
+    call_creat = 1;
+
+  /* Actually do the call.  */
+
+  if (call_creat)
+
+    /* Call creat.  May have to close and reopen the file if we want
+       O_RDONLY or O_RDWR access -- creat() only gives O_WRONLY.  */
+
+    {
+      int fd = creat (path, mode);
+
+      if (fd < 0 || (flags & O_WRONLY))
+	return fd;
+      if (close (fd) < 0)
+	return -1;
+
+      /* Fall out to reopen the file we've created.  */
+    }
+
+  /* Calling old open, we strip most of the new flags just in case.  */
+
+  return open (path, flags & (O_RDONLY | O_WRONLY | O_RDWR | O_BINARY));
+}
+
+#endif /* EMUL_OPEN3 */