--- /dev/null
+/* 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, ¤t_stat, ¤t_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;
+}
--- /dev/null
+/* 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 */
projects / chaz / tar / commitdiff
