Initial revision

src/diffarch.c

@@ -0,0 +1,702 @@
+/* Diff files from a tar archive.
+   Copyright (C) 1988 Free Software Foundation
+
+This file is part of GNU Tar.
+
+GNU Tar 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.
+
+GNU Tar 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 GNU Tar; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*
+ * Diff files from a tar archive.
+ *
+ * Written 30 April 1987 by John Gilmore, ihnp4!hoptoad!gnu.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#ifndef STDC_HEADERS
+extern int errno;
+#endif
+#include <sys/types.h>
+
+#ifdef BSD42
+#include <sys/file.h>
+#else
+#ifndef V7
+#include <fcntl.h>
+#endif
+#endif
+
+#ifndef NO_MTIO
+#include <sys/ioctl.h>
+#include <sys/mtio.h>
+#endif
+
+#include "tar.h"
+#include "port.h"
+#include "rmt.h"
+
+#ifndef S_ISLNK
+#define lstat stat
+#endif
+
+extern char *valloc();
+
+extern union record *head;		/* Points to current tape header */
+extern struct stat hstat;		/* Stat struct corresponding */
+extern int head_standard;		/* Tape header is in ANSI format */
+
+void decode_header();
+void diff_sparse_files();
+void fill_in_sparse_array();
+void fl_read();
+long from_oct();
+int do_stat();
+extern void print_header();
+int read_header();
+void saverec();
+void sigh();
+extern void skip_file();
+extern void skip_extended_headers();
+int wantbytes();
+
+extern FILE *msg_file;
+
+int now_verifying = 0;		/* Are we verifying at the moment? */
+
+int	diff_fd;		/* Descriptor of file we're diffing */
+
+char	*diff_buf = 0;		/* Pointer to area for reading
+					   file contents into */
+
+char	*diff_dir;		/* Directory contents for LF_DUMPDIR */
+
+int different = 0;
+
+/*struct sp_array *sparsearray;
+int 		sp_ar_size = 10;*/
+/*
+ * Initialize for a diff operation
+ */
+void
+diff_init()
+{
+	/*NOSTRICT*/
+	diff_buf = (char *) valloc((unsigned)blocksize);
+	if (!diff_buf) {
+		msg("could not allocate memory for diff buffer of %d bytes",
+			blocksize);
+		exit(EX_ARGSBAD);
+	}
+}
+
+/*
+ * Diff a file against the archive.
+ */
+void
+diff_archive()
+{
+	register char *data;
+	int check, namelen;
+	int err;
+	long offset;
+	struct stat filestat;
+	int compare_chunk();
+	int compare_dir();
+	int no_op();
+#ifndef __MSDOS__
+	dev_t	dev;
+	ino_t	ino;
+#endif
+	char *get_dir_contents();
+	long from_oct();
+
+	errno = EPIPE;			/* FIXME, remove perrors */
+
+	saverec(&head);			/* Make sure it sticks around */
+	userec(head);			/* And go past it in the archive */
+	decode_header(head, &hstat, &head_standard, 1);	/* Snarf fields */
+
+	/* Print the record from 'head' and 'hstat' */
+	if (f_verbose) {
+		if(now_verifying)
+			fprintf(msg_file,"Verify ");
+		print_header();
+	}
+
+	switch (head->header.linkflag) {
+
+	default:
+		msg("Unknown file type '%c' for %s, diffed as normal file",
+			head->header.linkflag, head->header.name);
+		/* FALL THRU */
+
+	case LF_OLDNORMAL:
+	case LF_NORMAL:
+	case LF_SPARSE:
+	case LF_CONTIG:
+		/*
+		 * Appears to be a file.
+		 * See if it's really a directory.
+		 */
+		namelen = strlen(head->header.name)-1;
+		if (head->header.name[namelen] == '/')
+			goto really_dir;
+
+		
+		if(do_stat(&filestat)) {
+			if (head->header.isextended)
+				skip_extended_headers();
+			skip_file((long)hstat.st_size);
+			different++;
+			goto quit;
+		}
+
+		if (!S_ISREG(filestat.st_mode)) {
+			fprintf(msg_file, "%s: not a regular file\n",
+				head->header.name);
+			skip_file((long)hstat.st_size);
+			different++;
+			goto quit;
+		}
+
+		filestat.st_mode &= 07777;
+		if (filestat.st_mode != hstat.st_mode)
+			sigh("mode");
+		if (filestat.st_uid  != hstat.st_uid)
+			sigh("uid");
+		if (filestat.st_gid  != hstat.st_gid)
+			sigh("gid");
+		if (filestat.st_mtime != hstat.st_mtime)
+			sigh("mod time");
+		if (head->header.linkflag != LF_SPARSE &&
+				filestat.st_size != hstat.st_size) {
+			sigh("size");
+			skip_file((long)hstat.st_size);
+			goto quit;
+		}
+
+		diff_fd = open(head->header.name, O_NDELAY|O_RDONLY|O_BINARY);
+
+		if (diff_fd < 0 && !f_absolute_paths) {
+			char tmpbuf[NAMSIZ+2];
+
+			tmpbuf[0]='/';
+			strcpy(&tmpbuf[1],head->header.name);
+			diff_fd=open(tmpbuf, O_NDELAY|O_RDONLY);
+		}
+		if (diff_fd < 0) {
+			msg_perror("cannot open %s",head->header.name);
+			if (head->header.isextended)
+				skip_extended_headers();
+			skip_file((long)hstat.st_size);
+			different++;
+			goto quit;
+		}
+		/*
+		 * Need to treat sparse files completely differently here.
+		 */
+		if (head->header.linkflag == LF_SPARSE)
+			diff_sparse_files(hstat.st_size);
+		else 
+			wantbytes((long)(hstat.st_size),compare_chunk);
+
+		check = close(diff_fd);
+		if (check < 0)
+			msg_perror("Error while closing %s",head->header.name);
+
+	quit:
+		break;
+
+#ifndef __MSDOS__
+	case LF_LINK:
+		if(do_stat(&filestat))
+			break;
+		dev = filestat.st_dev;
+		ino = filestat.st_ino;
+		err = stat(head->header.linkname, &filestat);
+		if (err < 0) {
+			if (errno==ENOENT) {
+				fprintf(msg_file, "%s: does not exist\n",head->header.name);
+			} else {
+				msg_perror("cannot stat file %s",head->header.name);
+			}
+			different++;
+			break;
+		}
+		if(filestat.st_dev!=dev || filestat.st_ino!=ino) {
+			fprintf(msg_file, "%s not linked to %s\n",head->header.name,head->header.linkname);
+			break;
+		}
+		break;
+#endif
+
+#ifdef S_ISLNK
+	case LF_SYMLINK:
+	{
+		char linkbuf[NAMSIZ+3];
+		check = readlink(head->header.name, linkbuf,
+				 (sizeof linkbuf)-1);
+		
+		if (check < 0) {
+			if (errno == ENOENT) {
+				fprintf(msg_file,
+					"%s: no such file or directory\n",
+					head->header.name);
+			} else {
+				msg_perror("cannot read link %s",head->header.name);
+			}
+			different++;
+			break;
+		}
+
+		linkbuf[check] = '\0';	/* Null-terminate it */
+		if (strncmp(head->header.linkname, linkbuf, check) != 0) {
+			fprintf(msg_file, "%s: symlink differs\n",
+				head->header.linkname);
+			different++;
+		}
+	}
+		break;
+#endif
+
+#ifdef S_IFCHR
+	case LF_CHR:
+		hstat.st_mode |= S_IFCHR;
+		goto check_node;
+#endif
+
+#ifdef S_IFBLK
+	/* If local system doesn't support block devices, use default case */
+	case LF_BLK:
+		hstat.st_mode |= S_IFBLK;
+		goto check_node;
+#endif
+
+#ifdef S_ISFIFO
+	/* If local system doesn't support FIFOs, use default case */
+	case LF_FIFO:
+#ifdef S_IFIFO
+		hstat.st_mode |= S_IFIFO;
+#endif
+		hstat.st_rdev = 0;		/* FIXME, do we need this? */
+		goto check_node;
+#endif
+
+	check_node:
+		/* FIXME, deal with umask */
+		if(do_stat(&filestat))
+			break;
+		if(hstat.st_rdev != filestat.st_rdev) {
+			fprintf(msg_file, "%s: device numbers changed\n", head->header.name);
+			different++;
+			break;
+		}
+#ifdef S_IFMT
+		if(hstat.st_mode != filestat.st_mode)
+#else /* POSIX lossage */
+		if((hstat.st_mode & 07777) != (filestat.st_mode & 07777))
+#endif
+		{
+			fprintf(msg_file, "%s: mode or device-type changed\n", head->header.name);
+			different++;
+			break;
+		}
+		break;
+
+	case LF_DUMPDIR:
+		data=diff_dir=get_dir_contents(head->header.name,0);
+		if (data) {
+			wantbytes((long)(hstat.st_size),compare_dir);
+			free(data);
+		} else
+			wantbytes((long)(hstat.st_size),no_op);
+		/* FALL THROUGH */
+
+	case LF_DIR:
+		/* Check for trailing / */
+		namelen = strlen(head->header.name)-1;
+	really_dir:
+		while (namelen && head->header.name[namelen] == '/')
+			head->header.name[namelen--] = '\0';	/* Zap / */
+
+		if(do_stat(&filestat))
+			break;
+		if(!S_ISDIR(filestat.st_mode)) {
+			fprintf(msg_file, "%s is no longer a directory\n",head->header.name);
+			different++;
+			break;
+		}
+		if((filestat.st_mode&07777) != (hstat.st_mode&07777))
+			sigh("mode");
+		break;
+
+	case LF_VOLHDR:
+		break;
+
+	case LF_MULTIVOL:
+		namelen = strlen(head->header.name)-1;
+		if (head->header.name[namelen] == '/')
+			goto really_dir;
+
+		if(do_stat(&filestat))
+			break;
+
+		if (!S_ISREG(filestat.st_mode)) {
+			fprintf(msg_file, "%s: not a regular file\n",
+				head->header.name);
+			skip_file((long)hstat.st_size);
+			different++;
+			break;
+		}
+
+		filestat.st_mode &= 07777;
+		offset = from_oct(1+12, head->header.offset);
+		if (filestat.st_size != hstat.st_size + offset) {
+			sigh("size");
+			skip_file((long)hstat.st_size);
+			different++;
+			break;
+		}
+
+		diff_fd = open(head->header.name, O_NDELAY|O_RDONLY|O_BINARY);
+
+		if (diff_fd < 0) {
+			msg_perror("cannot open file %s",head->header.name);
+			skip_file((long)hstat.st_size);
+			different++;
+			break;
+		}
+		err = lseek(diff_fd, offset, 0);
+		if(err!=offset) {
+			msg_perror("cannot seek to %ld in file %s",offset,head->header.name);
+			different++;
+			break;
+		}
+
+		wantbytes((long)(hstat.st_size),compare_chunk);
+
+		check = close(diff_fd);
+		if (check < 0) {
+			msg_perror("Error while closing %s",head->header.name);
+		}
+		break;
+
+	}
+
+	/* We don't need to save it any longer. */
+	saverec((union record **) 0);	/* Unsave it */
+}
+
+int
+compare_chunk(bytes,buffer)
+long bytes;
+char *buffer;
+{
+	int err;
+
+	err=read(diff_fd,diff_buf,bytes);
+	if(err!=bytes) {
+		if(err<0) {
+			msg_perror("can't read %s",head->header.name);
+		} else {
+			fprintf(msg_file,"%s: could only read %d of %d bytes\n",head->header.name,err,bytes);
+		}
+		different++;
+		return -1;
+	}
+	if(bcmp(buffer,diff_buf,bytes)) {
+		fprintf(msg_file, "%s: data differs\n",head->header.name);
+		different++;
+		return -1;
+	}
+	return 0;
+}
+
+int
+compare_dir(bytes,buffer)
+long bytes;
+char *buffer;
+{
+	if(bcmp(buffer,diff_dir,bytes)) {
+		fprintf(msg_file, "%s: data differs\n",head->header.name);
+		different++;
+		return -1;
+	}
+	diff_dir+=bytes;
+	return 0;
+}
+
+/*
+ * Sigh about something that differs.
+ */
+void
+sigh(what)
+	char *what;
+{
+
+	fprintf(msg_file, "%s: %s differs\n",
+		head->header.name, what);
+}
+
+void
+verify_volume()
+{
+	int status;
+#ifdef MTIOCTOP
+	struct mtop t;
+	int er;
+#endif
+
+	if(!diff_buf)
+		diff_init();
+#ifdef MTIOCTOP
+	t.mt_op = MTBSF;
+	t.mt_count = 1;
+	if((er=rmtioctl(archive,MTIOCTOP,&t))<0) {
+		if(errno!=EIO || (er=rmtioctl(archive,MTIOCTOP,&t))<0) {
+#endif
+			if(rmtlseek(archive,0L,0)!=0) {
+				/* Lseek failed.  Try a different method */
+				msg_perror("Couldn't rewind archive file for verify");
+				return;
+			}
+#ifdef MTIOCTOP
+		}
+	}
+#endif
+	ar_reading=1;
+	now_verifying = 1;
+	fl_read();
+	for(;;) {
+		status = read_header();
+		if(status==0) {
+			unsigned n;
+
+			n=0;
+			do {
+				n++;
+				status=read_header();
+			} while(status==0);
+			msg("VERIFY FAILURE: %d invalid header%s detected!",n,n==1?"":"s");
+		}
+		if(status==2 || status==EOF)
+			break;
+		diff_archive();
+	}
+	ar_reading=0;
+	now_verifying = 0;
+
+}
+
+int
+do_stat(statp)
+struct stat *statp;
+{
+	int err;
+
+	err = f_follow_links ? stat(head->header.name, statp) : lstat(head->header.name, statp);
+	if (err < 0) {
+		if (errno==ENOENT) {
+			fprintf(msg_file, "%s: does not exist\n",head->header.name);
+		} else
+			msg_perror("can't stat file %s",head->header.name);
+/*		skip_file((long)hstat.st_size);
+		different++;*/
+		return 1;
+	} else
+		return 0;
+}
+
+/*
+ * 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.  
+ */
+
+void
+diff_sparse_files(filesize)
+int	filesize;
+
+{
+	int		sparse_ind = 0;
+	char		*buf;
+	int		buf_size = RECORDSIZE;
+	union record 	*datarec;	
+	int		err;
+	long		numbytes;
+/*	int		amt_read = 0;*/
+	int		size = filesize;
+
+	buf = (char *) malloc(buf_size * sizeof (char));
+	
+	fill_in_sparse_array();
+	
+
+	while (size > 0) {
+		datarec = findrec();
+		if (!sparsearray[sparse_ind].numbytes)
+			break;
+
+		/*
+		 * 'numbytes' is nicer to write than
+		 * 'sparsearray[sparse_ind].numbytes' all the time ...
+		 */
+		numbytes = sparsearray[sparse_ind].numbytes;
+		
+		lseek(diff_fd, sparsearray[sparse_ind].offset, 0);
+		/*
+		 * take care to not run out of room in our buffer
+		 */
+		while (buf_size < numbytes) {
+			buf = (char *) realloc(buf, buf_size * 2 * sizeof(char));
+			buf_size *= 2;
+		}
+		while (numbytes > RECORDSIZE) {
+			if ((err = read(diff_fd, buf, RECORDSIZE)) != RECORDSIZE) {
+	 			if (err < 0) 
+					msg_perror("can't read %s", head->header.name);
+				else
+					fprintf(msg_file, "%s: could only read %d of %d bytes\n", 
+						err, numbytes);
+				break;
+			}
+			if (bcmp(buf, datarec->charptr, RECORDSIZE)) {
+				different++;
+				break;
+			}
+			numbytes -= err;
+			size -= err;
+			userec(datarec);
+			datarec = findrec();
+		}
+		if ((err = read(diff_fd, buf, numbytes)) != numbytes) {
+ 			if (err < 0) 
+				msg_perror("can't read %s", head->header.name);
+			else
+				fprintf(msg_file, "%s: could only read %d of %d bytes\n", 
+						err, numbytes);
+			break;
+		}
+
+		if (bcmp(buf, datarec->charptr, numbytes)) {
+			different++;
+			break;
+		}
+/*		amt_read += numbytes;
+		if (amt_read >= RECORDSIZE) {
+			amt_read = 0;
+			userec(datarec);
+			datarec = findrec();
+		}*/
+		userec(datarec);
+		sparse_ind++;
+		size -= numbytes;
+	}
+	/* 
+	 * if the number of bytes read isn't the
+	 * number of bytes supposedly in the file,
+	 * they're different
+	 */
+/*	if (amt_read != filesize)
+		different++;*/
+	userec(datarec);
+	free(sparsearray);
+	if (different)
+		fprintf(msg_file, "%s: data differs\n", head->header.name);
+
+}
+
+/*
+ * 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.
+ */
+void
+fill_in_sparse_array()
+{
+	int 	ind;
+
+	/*
+	 * 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 *) malloc(sp_array_size * sizeof(struct sp_array));
+
+	/*
+	 * there are at most five of these structures in the header
+	 * itself; read these in first
+	 */
+	for (ind = 0; ind < SPARSE_IN_HDR; ind++) {
+		if (!head->header.sp[ind].numbytes)
+			break;
+		sparsearray[ind].offset =
+			from_oct(1+12, head->header.sp[ind].offset);
+		sparsearray[ind].numbytes =
+			from_oct(1+12, head->header.sp[ind].numbytes);
+	}
+	/*
+	 * if the header's extended, we gotta read in exhdr's till
+	 * we're done
+	 */
+	if (head->header.isextended) {
+ 	    /* how far into the sparsearray we are 'so far' */
+	    static int so_far_ind = SPARSE_IN_HDR;	
+	    union record *exhdr;
+   	    
+	    for (;;) {
+		exhdr = findrec();
+		for (ind = 0; ind < SPARSE_EXT_HDR; ind++) {
+			if (ind+so_far_ind > sp_array_size-1) {
+				/*
+ 				 * we just ran out of room in our
+				 *  scratch area - realloc it
+ 				 */
+				sparsearray = (struct sp_array *)
+					realloc(sparsearray, 
+						sp_array_size*2*sizeof(struct sp_array));
+				sp_array_size *= 2;
+			}
+			/*
+			 * convert the character strings into longs
+			 */
+			sparsearray[ind+so_far_ind].offset = 
+			    from_oct(1+12, exhdr->ext_hdr.sp[ind].offset);
+			sparsearray[ind+so_far_ind].numbytes =
+			    from_oct(1+12, exhdr->ext_hdr.sp[ind].numbytes);
+		}
+		/* 
+		 * if this is the last extended header for this
+		 * file, we can stop
+		 */
+		if (!exhdr->ext_hdr.isextended)
+			break;
+		else {
+			so_far_ind += SPARSE_EXT_HDR;
+			userec(exhdr);
+		}
+	    }
+	    /* be sure to skip past the last one  */
+	    userec(exhdr);
+	}
+}