/*

	Copyright (C) 1988 Free Software Foundation

GNU tar is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY.  No author or distributor accepts responsibility to anyone
for the consequences of using it or for whether it serves any
particular purpose or works at all, unless he says so in writing.
Refer to the GNU tar General Public License for full details.

Everyone is granted permission to copy, modify and redistribute GNU tar,
but only under the conditions described in the GNU tar General Public
License.  A copy of this license is supposed to have been given to you
along with GNU tar so you can know your rights and responsibilities.  It
should be in a file named COPYING.  Among other things, the copyright
notice and this notice must be preserved on all copies.

In other words, go ahead and share GNU tar, but don't try to stop
anyone else from sharing it farther.  Help stamp out software hoarding!
*/

/* JF implement the 'r' 'u' and 'A' options for tar. */
/* The 'A' option is my own invention:  It means that the file-names are
   tar files, and they should simply be appended to the end of the archive.
   No attempt is made to block the reads from the args; if they're on raw
   tape or something like that, it'll probably lose. . . */

#ifdef atarist
#include <types.h>
#include <stat.h>
#else
#include <sys/types.h>
#include <sys/stat.h>
#endif
#include <stdio.h>
#include <errno.h>

/* JF these includes are copied from create.c  I'm not sure if they're right
   or not.  */
#ifndef V7
#include <fcntl.h>
#endif

#ifndef	MSDOS
#include <pwd.h>
#include <grp.h>
#endif

#ifdef USG
#include <sys/sysmacros.h>	/* major() and minor() defined here */
#endif

/*
 * V7 doesn't have a #define for this.
 */
#ifndef O_RDONLY
#define	O_RDONLY	0
#endif

/*
 * Most people don't have a #define for this.
 */
#ifndef	O_BINARY
#define	O_BINARY	0
#endif

#define STDIN 0
#define STDOUT 1

#include "tar.h"
#include "port.h"
#include "rmt.h"

int time_to_start_writing = 0;	/* We've hit the end of the old stuff,
				   and its time to start writing new stuff
				   to the tape.  This involves seeking
				   back one block and re-writing the current
				   block (which has been changed). */

char *output_start;		/* Pointer to where we started to write in
				   the first block we write out.  This is used
				   if we can't backspace the output and have
				   to null out the first part of the block */

extern void skip_file();

extern union record *head;
extern struct stat hstat;

struct name *name_scan();
char	*name_from_list();

/* Implement the 'r' (add files to end of archive), and 'u' (add files to
   end of archive if they arent there, or are more up to date than the
   version in the archive.) commands.*/
void
update_archive()
{
	int	found_end = 0;
	int	status = 3;
	int	prev_status;
	char	*p;
	struct name *name;
	extern void dump_file();

	name_gather();
	if(cmd_mode==CMD_UPDATE)
		name_expand();
	open_archive(2);	/* Open for updating */

	do {
		prev_status=status;
		status=read_header();
		switch(status) {
		case EOF:
			found_end=1;
			break;

		case 0:		/* A bad record */
			userec(head);
			switch(prev_status) {
			case 3:
				msg("This doesn't look like a tar archive.\n");
				/* FALL THROUGH */
			case 2:
			case 1:
				msg("Skipping to next header\n");
			case 0:
				break;
			}
			break;

			/* A good record */
		case 1:
 /* printf("File %s\n",head->header.name); */
			head->header.name[NAMSIZ-1]='\0';
			if(cmd_mode==CMD_UPDATE && (name=name_scan(head->header.name))) {
				/* struct stat hstat; */
				struct stat nstat;
				int head_standard;

				decode_header(head,&hstat,&head_standard,0);
				if(stat(head->header.name,&nstat)<0) {
					msg_perror("can't stat %s:",head->header.name);
				} else {
					if(hstat.st_mtime>=nstat.st_mtime)
						name->found++;
				}
			}
			userec(head);
			skip_file((long)hstat.st_size);
			break;

		case 2:
			ar_record=head;
			found_end = 1;
			break;
		}
	} while(!found_end);

	time_to_start_writing = 1;
	output_start=ar_record->charptr;

	while(p=name_from_list()) {
		if(f_confirm && !confirm("add", p))
			continue;
		if(cmd_mode==CMD_CAT)
			append_file(p);
		else
			dump_file(p,-1);
	}

	write_eot();
	close_archive();
	names_notfound();
}

/* Catenate file p to the archive without creating a header for it.  It had
   better be a tar file or the archive is screwed */

append_file(p)
char *p;
{
	int	fd;
	struct stat statbuf;
	long	bytes_left;
	union record *start;
	long	bufsiz,count;

	if(0 != stat(p,&statbuf) || (fd=open(p,O_RDONLY|O_BINARY))<0) {
		msg_perror("can't open file %s",p);
		errors++;
		return;
	}

	bytes_left = statbuf.st_size;

	while(bytes_left>0) {
		start=findrec();
		bufsiz=endofrecs()->charptr - start->charptr;
		if(bytes_left < bufsiz) {
			bufsiz = bytes_left;
			count = bufsiz % RECORDSIZE;
			if(count)
				bzero(start->charptr + bytes_left,(int)(RECORDSIZE-count));
		}
		count=read(fd,start->charptr,bufsiz);
		if(count<0) {
			msg_perror("read error at byte %ld reading %d bytes in file %s",statbuf.st_size-bytes_left,bufsiz,p);
			exit(EX_ARGSBAD);		/* FOO */
		}
		bytes_left-=count;
		userec(start+(count-1)/RECORDSIZE);
		if(count!=bufsiz) {
			msg("%s: file shrunk by %d bytes, yark!\n",p,bytes_left);
			abort();
		}
	}
	(void)close(fd);
}

#ifdef DONTDEF
bprint(fp,buf,num)
FILE *fp;
char *buf;
{
	int	c;

	if(num==0 || num==-1)
		return;
	fputs(" '",fp);
	while(num--) {
		c= *buf++;
		if(c=='\\') fputs("\\\\",fp);
		else if(c>=' ' && c<='~')
			putc(c,fp);
		else switch(c) {
		case '\n':
			fputs("\\n",fp);
			break;
		case '\r':
			fputs("\\r",fp);
			break;
		case '\b':
			fputs("\\b",fp);
			break;
		case '\0':
			/* fputs("\\-",fp); */
			break;
		default:
			fprintf(fp,"\\%03o",c);
			break;
		}
	}
	fputs("'\n",fp);
}
#endif

int number_of_blocks_read = 0;

int number_of_new_records = 0;
int number_of_records_needed = 0;

union record *new_block = 0;
union record *save_block = 0;

void
junk_archive()
{
	int	found_stuff = 0;
	int	status = 3;
	int	prev_status;
	struct name *name;

	/* int dummy_head; */
	int number_of_records_to_skip = 0;
	int number_of_records_to_keep = 0;
	int number_of_kept_records_in_block;
	int sub_status;
	extern int write_archive_to_stdout;

/* fprintf(stderr,"Junk files\n"); */
	name_gather();
	open_archive(2);

	while(!found_stuff) {
		prev_status=status;
		status=read_header();
		switch(status) {
		case EOF:
			found_stuff = 1;
			break;

		case 0:
			userec(head);
			switch(prev_status) {
			case 3:
				msg("This doesn't look like a tar archive.\n");
				/* FALL THROUGH */
			case 2:
			case 1:
				msg("Skipping to next header\n");
				/* FALL THROUGH */
			case 0:
				break;
			}
			break;

		case 1:
			head->header.name[NAMSIZ-1] = '\0';
 /* fprintf(stderr,"file %s\n",head->header.name); */
			if((name=name_scan(head->header.name))==(struct name *)0) {
				userec(head);
 /* fprintf(stderr,"Skip %ld\n",(long)(hstat.st_size)); */
				skip_file((long)(hstat.st_size));
				break;
			}
			name->found = 1;
			found_stuff = 2;
			break;

		case 2:
			found_stuff = 1;
			break;
		}
	}
 /* fprintf(stderr,"Out of first loop\n"); */

	if(found_stuff!=2) {
		write_eot();
		close_archive();
		names_notfound();
		return;
	}

	if(write_archive_to_stdout)
		write_archive_to_stdout = 0;
	new_block = (union record *)malloc(blocksize);
	if(new_block==0) {
		fprintf(stderr,"Can't allocate secondary block of %d bytes\n",blocksize);
		exit(EX_SYSTEM);
	}

		/* Save away records before this one in this block */
	number_of_new_records=ar_record-ar_block;
	number_of_records_needed = blocking - number_of_new_records;
	if(number_of_new_records)
		bcopy((void *)ar_block,(void *)new_block,(number_of_new_records)*RECORDSIZE);

 /* fprintf(stderr,"Saved %d recs, need %d more\n",number_of_new_records,number_of_records_needed); */
	userec(head);
	skip_file((long)(hstat.st_size));
	found_stuff=0;
	/* goto flush_file; */

	for(;;) {
			/* Fill in a block */
	/* another_file: */
		if(ar_record==ar_last) {
 /* fprintf(stderr,"New block\n"); */
			flush_archive();
			number_of_blocks_read++;
		}
		sub_status = read_header();
 /* fprintf(stderr,"Header type %d\n",sub_status); */

		if(sub_status==2 && f_ignorez) {
			userec(head);
			continue;
		}
		if(sub_status==EOF || sub_status==2) {
			found_stuff = 1;
			bzero(new_block[number_of_new_records].charptr,RECORDSIZE*number_of_records_needed);
			number_of_new_records+=number_of_records_needed;
			number_of_records_needed = 0;
			write_block(0);
			break;
		}

		if(sub_status==0) {
			fprintf(stderr,"Deleting non-header from archive.\n");
			userec(head);
			continue;
		}

		/* Found another header.  Yipee! */
		head->header.name[NAMSIZ-1] = '\0';
 /* fprintf(stderr,"File %s ",head->header.name); */
		if(name=name_scan(head->header.name)) {
			name->found = 1;
 /* fprintf(stderr,"Flush it\n"); */
		/* flush_file: */
			/* decode_header(head,&hstat,&dummy_head,0); */
			userec(head);
			number_of_records_to_skip=(hstat.st_size+RECORDSIZE-1)/RECORDSIZE;
 /* fprintf(stderr,"Flushing %d recs from %s\n",number_of_records_to_skip,head->header.name); */

			while(ar_last-ar_record<=number_of_records_to_skip) {

 /* fprintf(stderr,"Block: %d <= %d  ",ar_last-ar_record,number_of_records_to_skip); */
				number_of_records_to_skip -= (ar_last - ar_record);
				flush_archive();
				number_of_blocks_read++;
 /* fprintf(stderr,"Block %d left\n",number_of_records_to_skip); */
			}
			ar_record+=number_of_records_to_skip;
 /* fprintf(stderr,"Final %d\n",number_of_records_to_skip); */
			number_of_records_to_skip = 0;
			continue;
		}

	/* copy_header: */
		new_block[number_of_new_records]= *head;
		number_of_new_records++;
		number_of_records_needed--;
		number_of_records_to_keep=(hstat.st_size+RECORDSIZE-1)/RECORDSIZE;
		userec(head);
		if(number_of_records_needed==0)
			write_block(1);
	/* copy_data: */
		number_of_kept_records_in_block = ar_last - ar_record;
		if(number_of_kept_records_in_block > number_of_records_to_keep)
			number_of_kept_records_in_block = number_of_records_to_keep;

 /* fprintf(stderr,"Need %d kept_in %d keep %d\n",blocking,number_of_kept_records_in_block,number_of_records_to_keep); */

		while(number_of_records_to_keep) {
			int n;

			if(ar_record==ar_last) {
 /* fprintf(stderr,"Flush. . .\n"); */
				fl_read();
				number_of_blocks_read++;
				ar_record=ar_block;
				number_of_kept_records_in_block = blocking;
				if(number_of_kept_records_in_block > number_of_records_to_keep)
					number_of_kept_records_in_block = number_of_records_to_keep;
			}
			n = number_of_kept_records_in_block;
			if(n>number_of_records_needed)
				n = number_of_records_needed;

 /* fprintf(stderr,"Copying %d\n",n); */
			bcopy((void *)ar_record, (void *)(new_block+number_of_new_records), n*RECORDSIZE);
			number_of_new_records           += n;
			number_of_records_needed        -= n;
			ar_record                       += n;
			number_of_records_to_keep       -= n;
			number_of_kept_records_in_block -= n;
 /* fprintf(stderr,"Now new %d  need %d  keep %d  keep_in %d rec %d/%d\n", 
 number_of_new_records,number_of_records_needed,number_of_records_to_keep,
 number_of_kept_records_in_block,ar_record-ar_block,ar_last-ar_block); */
 
			if(number_of_records_needed == 0) {
				write_block(1);
			}
		}
	}

	write_eot();
	close_archive();
	names_notfound();
}

write_block(f)
{
 /* fprintf(stderr,"Write block\n"); */
	/* We've filled out a block.  Write it out. */

	/* Backspace back to where we started. . . */
	if(archive!=STDIN)
		(void)move_arch(-(number_of_blocks_read+1));

	save_block = ar_block;
	ar_block = new_block;

	if(archive==STDIN)
		archive=STDOUT;
	fl_write();

	if(archive==STDOUT)
		archive=STDIN;
	ar_block = save_block;

	if(f) {
		/* Move the tape head back to where we were */
		if(archive!=STDIN)
			(void)move_arch(number_of_blocks_read);
		number_of_blocks_read--;
	}

	number_of_records_needed = blocking;
	number_of_new_records = 0;
}

/* Move archive descriptor by n blocks worth.  If n is positive we move
   forward, else we move negative.   If its a tape, MTIOCTOP had better
   work.  If its something else, we try to seek on it.  If we can't
   seek, we lose! */
move_arch(n)
{
	long cur;
	extern int errno;

#ifdef MTIOCTOP
	struct mtop t;
	int er;

	if(n>0) {
		t.mt_op = MTFSR;
		t.mt_count = n;
	} else {
		t.mt_op = MTBSR;
		t.mt_count = -n;
	}
	if((er=rmtioctl(archive,MTIOCTOP,&t))>=0)
		return 1;
	if(errno==EIO && (er=rmtioctl(archive,MTIOCTOP,&t))>=0)
		return 1;
#endif

	cur=rmtlseek(archive,0L,1);
	cur+=blocksize*n;

 /* fprintf(stderr,"Fore to %x\n",cur); */
	if(rmtlseek(archive,cur,0)!=cur) {
		/* Lseek failed.  Try a different method */
		fprintf(stderr,"tar: Couldn't re-position archive file.\n");
		exit(EX_BADARCH);
	}
	return 3;
}