tape.c revision 92837 
1/*
2 * Copyright (c) 1983, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 *    must display the following acknowledgement:
20 *	This product includes software developed by the University of
21 *	California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 *    may be used to endorse or promote products derived from this software
24 *    without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 */
38
39#ifndef lint
40#if 0
41static char sccsid[] = "@(#)tape.c	8.9 (Berkeley) 5/1/95";
42#endif
43static const char rcsid[] =
44  "$FreeBSD: head/sbin/restore/tape.c 92837 2002-03-20 22:49:40Z imp $";
45#endif /* not lint */
46
47#include <sys/param.h>
48#include <sys/file.h>
49#include <sys/mtio.h>
50#include <sys/stat.h>
51#include <sys/time.h>
52
53#include <ufs/ufs/dinode.h>
54#include <protocols/dumprestore.h>
55
56#include <errno.h>
57#include <paths.h>
58#include <setjmp.h>
59#include <stdio.h>
60#include <stdlib.h>
61#include <string.h>
62#include <time.h>
63#include <unistd.h>
64
65#include "restore.h"
66#include "extern.h"
67
68static long	fssize = MAXBSIZE;
69static int	mt = -1;
70static int	pipein = 0;
71static char	*magtape;
72static int	blkcnt;
73static int	numtrec;
74static char	*tapebuf;
75static union	u_spcl endoftapemark;
76static long	blksread;		/* blocks read since last header */
77static long	tapeaddr = 0;		/* current TP_BSIZE tape record */
78static long	tapesread;
79static jmp_buf	restart;
80static int	gettingfile = 0;	/* restart has a valid frame */
81static char	*host = NULL;
82
83static int	ofile;
84static char	*map;
85static char	lnkbuf[MAXPATHLEN + 1];
86static int	pathlen;
87
88int		oldinofmt;	/* old inode format conversion required */
89int		Bcvt;		/* Swap Bytes (for CCI or sun) */
90static int	Qcvt;		/* Swap quads (for sun) */
91
92#define	FLUSHTAPEBUF()	blkcnt = ntrec + 1
93
94static void	 accthdr(struct s_spcl *);
95static int	 checksum(int *);
96static void	 findinode(struct s_spcl *);
97static void	 findtapeblksize(void);
98static int	 gethead(struct s_spcl *);
99static void	 readtape(char *);
100static void	 setdumpnum(void);
101static u_long	 swabl(u_long);
102static u_char	*swablong(u_char *, int);
103static u_char	*swabshort(u_char *, int);
104static void	 terminateinput(void);
105static void	 xtrfile(char *, long);
106static void	 xtrlnkfile(char *, long);
107static void	 xtrlnkskip(char *, long);
108static void	 xtrmap(char *, long);
109static void	 xtrmapskip(char *, long);
110static void	 xtrskip(char *, long);
111
112static int readmapflag;
113
114/*
115 * Set up an input source
116 */
117void
118setinput(char *source)
119{
120	FLUSHTAPEBUF();
121	if (bflag)
122		newtapebuf(ntrec);
123	else
124		newtapebuf(NTREC > HIGHDENSITYTREC ? NTREC : HIGHDENSITYTREC);
125	terminal = stdin;
126
127#ifdef RRESTORE
128	if (strchr(source, ':')) {
129		host = source;
130		source = strchr(host, ':');
131		*source++ = '\0';
132		if (rmthost(host) == 0)
133			done(1);
134	} else
135#endif
136	if (strcmp(source, "-") == 0) {
137		/*
138		 * Since input is coming from a pipe we must establish
139		 * our own connection to the terminal.
140		 */
141		terminal = fopen(_PATH_TTY, "r");
142		if (terminal == NULL) {
143			(void)fprintf(stderr, "cannot open %s: %s\n",
144			    _PATH_TTY, strerror(errno));
145			terminal = fopen(_PATH_DEVNULL, "r");
146			if (terminal == NULL) {
147				(void)fprintf(stderr, "cannot open %s: %s\n",
148				    _PATH_DEVNULL, strerror(errno));
149				done(1);
150			}
151		}
152		pipein++;
153	}
154	setuid(getuid());	/* no longer need or want root privileges */
155	magtape = strdup(source);
156	if (magtape == NULL) {
157		fprintf(stderr, "Cannot allocate space for magtape buffer\n");
158		done(1);
159	}
160}
161
162void
163newtapebuf(long size)
164{
165	static int tapebufsize = -1;
166
167	ntrec = size;
168	if (size <= tapebufsize)
169		return;
170	if (tapebuf != NULL)
171		free(tapebuf);
172	tapebuf = malloc(size * TP_BSIZE);
173	if (tapebuf == NULL) {
174		fprintf(stderr, "Cannot allocate space for tape buffer\n");
175		done(1);
176	}
177	tapebufsize = size;
178}
179
180/*
181 * Verify that the tape drive can be accessed and
182 * that it actually is a dump tape.
183 */
184void
185setup(void)
186{
187	int i, j, *ip;
188	struct stat stbuf;
189
190	vprintf(stdout, "Verify tape and initialize maps\n");
191#ifdef RRESTORE
192	if (host)
193		mt = rmtopen(magtape, 0);
194	else
195#endif
196	if (pipein)
197		mt = 0;
198	else
199		mt = open(magtape, O_RDONLY, 0);
200	if (mt < 0) {
201		fprintf(stderr, "%s: %s\n", magtape, strerror(errno));
202		done(1);
203	}
204	volno = 1;
205	setdumpnum();
206	FLUSHTAPEBUF();
207	if (!pipein && !bflag)
208		findtapeblksize();
209	if (gethead(&spcl) == FAIL) {
210		blkcnt--; /* push back this block */
211		blksread--;
212		cvtflag++;
213		if (gethead(&spcl) == FAIL) {
214			fprintf(stderr, "Tape is not a dump tape\n");
215			done(1);
216		}
217		fprintf(stderr, "Converting to new file system format.\n");
218	}
219	if (pipein) {
220		endoftapemark.s_spcl.c_magic = cvtflag ? OFS_MAGIC : NFS_MAGIC;
221		endoftapemark.s_spcl.c_type = TS_END;
222		ip = (int *)&endoftapemark;
223		j = sizeof(union u_spcl) / sizeof(int);
224		i = 0;
225		do
226			i += *ip++;
227		while (--j);
228		endoftapemark.s_spcl.c_checksum = CHECKSUM - i;
229	}
230	if (vflag || command == 't')
231		printdumpinfo();
232	dumptime = _time32_to_time(spcl.c_ddate);
233	dumpdate = _time32_to_time(spcl.c_date);
234	if (stat(".", &stbuf) < 0) {
235		fprintf(stderr, "cannot stat .: %s\n", strerror(errno));
236		done(1);
237	}
238	if (stbuf.st_blksize > 0 && stbuf.st_blksize < TP_BSIZE )
239		fssize = TP_BSIZE;
240	if (stbuf.st_blksize >= TP_BSIZE && stbuf.st_blksize <= MAXBSIZE)
241		fssize = stbuf.st_blksize;
242	if (((fssize - 1) & fssize) != 0) {
243		fprintf(stderr, "bad block size %ld\n", fssize);
244		done(1);
245	}
246	if (spcl.c_volume != 1) {
247		fprintf(stderr, "Tape is not volume 1 of the dump\n");
248		done(1);
249	}
250	if (gethead(&spcl) == FAIL) {
251		dprintf(stdout, "header read failed at %ld blocks\n", blksread);
252		panic("no header after volume mark!\n");
253	}
254	findinode(&spcl);
255	if (spcl.c_type != TS_CLRI) {
256		fprintf(stderr, "Cannot find file removal list\n");
257		done(1);
258	}
259	maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1;
260	dprintf(stdout, "maxino = %d\n", maxino);
261	map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
262	if (map == NULL)
263		panic("no memory for active inode map\n");
264	usedinomap = map;
265	curfile.action = USING;
266	getfile(xtrmap, xtrmapskip);
267	if (spcl.c_type != TS_BITS) {
268		fprintf(stderr, "Cannot find file dump list\n");
269		done(1);
270	}
271	map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY));
272	if (map == (char *)NULL)
273		panic("no memory for file dump list\n");
274	dumpmap = map;
275	curfile.action = USING;
276	getfile(xtrmap, xtrmapskip);
277	/*
278	 * If there may be whiteout entries on the tape, pretend that the
279	 * whiteout inode exists, so that the whiteout entries can be
280	 * extracted.
281	 */
282	if (oldinofmt == 0)
283		SETINO(WINO, dumpmap);
284	/* 'r' restores don't call getvol() for tape 1, so mark it as read. */
285	if (command == 'r')
286		tapesread = 1;
287}
288
289/*
290 * Prompt user to load a new dump volume.
291 * "Nextvol" is the next suggested volume to use.
292 * This suggested volume is enforced when doing full
293 * or incremental restores, but can be overridden by
294 * the user when only extracting a subset of the files.
295 */
296void
297getvol(long nextvol)
298{
299	long newvol, prevtapea, savecnt, i;
300	union u_spcl tmpspcl;
301#	define tmpbuf tmpspcl.s_spcl
302	char buf[TP_BSIZE];
303
304	if (nextvol == 1) {
305		tapesread = 0;
306		gettingfile = 0;
307	}
308	prevtapea = tapeaddr;
309	savecnt = blksread;
310	if (pipein) {
311		if (nextvol != 1) {
312			panic("Changing volumes on pipe input?\n");
313			/* Avoid looping if we couldn't ask the user. */
314			if (yflag || ferror(terminal) || feof(terminal))
315				done(1);
316		}
317		if (volno == 1)
318			return;
319		goto gethdr;
320	}
321again:
322	if (pipein)
323		done(1); /* pipes do not get a second chance */
324	if (command == 'R' || command == 'r' || curfile.action != SKIP)
325		newvol = nextvol;
326	else
327		newvol = 0;
328	while (newvol <= 0) {
329		if (tapesread == 0) {
330			fprintf(stderr, "%s%s%s%s%s%s%s",
331			    "You have not read any tapes yet.\n",
332			    "If you are extracting just a few files,",
333			    " start with the last volume\n",
334			    "and work towards the first; restore",
335			    " can quickly skip tapes that\n",
336			    "have no further files to extract.",
337			    " Otherwise, begin with volume 1.\n");
338		} else {
339			fprintf(stderr, "You have read volumes");
340			strcpy(buf, ": ");
341			for (i = 0; i < 32; i++)
342				if (tapesread & (1 << i)) {
343					fprintf(stderr, "%s%ld", buf, i + 1);
344					strcpy(buf, ", ");
345				}
346			fprintf(stderr, "\n");
347		}
348		do	{
349			fprintf(stderr, "Specify next volume #: ");
350			(void) fflush(stderr);
351			if (fgets(buf, BUFSIZ, terminal) == NULL)
352				done(1);
353		} while (buf[0] == '\n');
354		newvol = atoi(buf);
355		if (newvol <= 0) {
356			fprintf(stderr,
357			    "Volume numbers are positive numerics\n");
358		}
359	}
360	if (newvol == volno) {
361		tapesread |= 1 << (volno - 1);
362		return;
363	}
364	closemt();
365	fprintf(stderr, "Mount tape volume %ld\n", newvol);
366	fprintf(stderr, "Enter ``none'' if there are no more tapes\n");
367	fprintf(stderr, "otherwise enter tape name (default: %s) ", magtape);
368	(void) fflush(stderr);
369	if (fgets(buf, BUFSIZ, terminal) == NULL)
370		done(1);
371	if (!strcmp(buf, "none\n")) {
372		terminateinput();
373		return;
374	}
375	if (buf[0] != '\n') {
376		(void) strcpy(magtape, buf);
377		magtape[strlen(magtape) - 1] = '\0';
378	}
379#ifdef RRESTORE
380	if (host)
381		mt = rmtopen(magtape, 0);
382	else
383#endif
384		mt = open(magtape, O_RDONLY, 0);
385
386	if (mt == -1) {
387		fprintf(stderr, "Cannot open %s\n", magtape);
388		volno = -1;
389		goto again;
390	}
391gethdr:
392	volno = newvol;
393	setdumpnum();
394	FLUSHTAPEBUF();
395	if (gethead(&tmpbuf) == FAIL) {
396		dprintf(stdout, "header read failed at %ld blocks\n", blksread);
397		fprintf(stderr, "tape is not dump tape\n");
398		volno = 0;
399		goto again;
400	}
401	if (tmpbuf.c_volume != volno) {
402		fprintf(stderr, "Wrong volume (%ld)\n", tmpbuf.c_volume);
403		volno = 0;
404		goto again;
405	}
406	if (_time32_to_time(tmpbuf.c_date) != dumpdate ||
407	    _time32_to_time(tmpbuf.c_ddate) != dumptime) {
408		time_t t = _time32_to_time(tmpbuf.c_date);
409		fprintf(stderr, "Wrong dump date\n\tgot: %s", ctime(&t));
410		fprintf(stderr, "\twanted: %s", ctime(&dumpdate));
411		volno = 0;
412		goto again;
413	}
414	tapesread |= 1 << (volno - 1);
415	blksread = savecnt;
416 	/*
417 	 * If continuing from the previous volume, skip over any
418 	 * blocks read already at the end of the previous volume.
419 	 *
420 	 * If coming to this volume at random, skip to the beginning
421 	 * of the next record.
422 	 */
423	dprintf(stdout, "last rec %ld, tape starts with %ld\n", prevtapea,
424	    tmpbuf.c_tapea);
425 	if (tmpbuf.c_type == TS_TAPE && (tmpbuf.c_flags & DR_NEWHEADER)) {
426 		if (curfile.action != USING) {
427			/*
428			 * XXX Dump incorrectly sets c_count to 1 in the
429			 * volume header of the first tape, so ignore
430			 * c_count when volno == 1.
431			 */
432			if (volno != 1)
433				for (i = tmpbuf.c_count; i > 0; i--)
434					readtape(buf);
435 		} else if (tmpbuf.c_tapea <= prevtapea) {
436			/*
437			 * Normally the value of c_tapea in the volume
438			 * header is the record number of the header itself.
439			 * However in the volume header following an EOT-
440			 * terminated tape, it is the record number of the
441			 * first continuation data block (dump bug?).
442			 *
443			 * The next record we want is `prevtapea + 1'.
444			 */
445 			i = prevtapea + 1 - tmpbuf.c_tapea;
446			dprintf(stderr, "Skipping %ld duplicate record%s.\n",
447				i, i > 1 ? "s" : "");
448 			while (--i >= 0)
449 				readtape(buf);
450 		}
451 	}
452	if (curfile.action == USING) {
453		if (volno == 1)
454			panic("active file into volume 1\n");
455		return;
456	}
457	(void) gethead(&spcl);
458	findinode(&spcl);
459	if (gettingfile) {
460		gettingfile = 0;
461		longjmp(restart, 1);
462	}
463}
464
465/*
466 * Handle unexpected EOF.
467 */
468static void
469terminateinput(void)
470{
471
472	if (gettingfile && curfile.action == USING) {
473		printf("Warning: %s %s\n",
474		    "End-of-input encountered while extracting", curfile.name);
475	}
476	curfile.name = "<name unknown>";
477	curfile.action = UNKNOWN;
478	curfile.dip = NULL;
479	curfile.ino = maxino;
480	if (gettingfile) {
481		gettingfile = 0;
482		longjmp(restart, 1);
483	}
484}
485
486/*
487 * handle multiple dumps per tape by skipping forward to the
488 * appropriate one.
489 */
490static void
491setdumpnum(void)
492{
493	struct mtop tcom;
494
495	if (dumpnum == 1 || volno != 1)
496		return;
497	if (pipein) {
498		fprintf(stderr, "Cannot have multiple dumps on pipe input\n");
499		done(1);
500	}
501	tcom.mt_op = MTFSF;
502	tcom.mt_count = dumpnum - 1;
503#ifdef RRESTORE
504	if (host)
505		rmtioctl(MTFSF, dumpnum - 1);
506	else
507#endif
508		if (ioctl(mt, MTIOCTOP, (char *)&tcom) < 0)
509			fprintf(stderr, "ioctl MTFSF: %s\n", strerror(errno));
510}
511
512void
513printdumpinfo(void)
514{
515	time_t t;
516	t = _time32_to_time(spcl.c_date);
517	fprintf(stdout, "Dump   date: %s", ctime(&t));
518	t = _time32_to_time(spcl.c_ddate);
519	fprintf(stdout, "Dumped from: %s",
520	    (spcl.c_ddate == 0) ? "the epoch\n" : ctime(&t));
521	if (spcl.c_host[0] == '\0')
522		return;
523	fprintf(stderr, "Level %ld dump of %s on %s:%s\n",
524		spcl.c_level, spcl.c_filesys, spcl.c_host, spcl.c_dev);
525	fprintf(stderr, "Label: %s\n", spcl.c_label);
526}
527
528int
529extractfile(char *name)
530{
531	int flags;
532	mode_t mode;
533	struct timeval timep[2];
534	struct entry *ep;
535
536	curfile.name = name;
537	curfile.action = USING;
538	timep[0].tv_sec = curfile.dip->di_atime;
539	timep[0].tv_usec = curfile.dip->di_atimensec / 1000;
540	timep[1].tv_sec = curfile.dip->di_mtime;
541	timep[1].tv_usec = curfile.dip->di_mtimensec / 1000;
542	mode = curfile.dip->di_mode;
543	flags = curfile.dip->di_flags;
544	switch (mode & IFMT) {
545
546	default:
547		fprintf(stderr, "%s: unknown file mode 0%o\n", name, mode);
548		skipfile();
549		return (FAIL);
550
551	case IFSOCK:
552		vprintf(stdout, "skipped socket %s\n", name);
553		skipfile();
554		return (GOOD);
555
556	case IFDIR:
557		if (mflag) {
558			ep = lookupname(name);
559			if (ep == NULL || ep->e_flags & EXTRACT)
560				panic("unextracted directory %s\n", name);
561			skipfile();
562			return (GOOD);
563		}
564		vprintf(stdout, "extract file %s\n", name);
565		return (genliteraldir(name, curfile.ino));
566
567	case IFLNK:
568		lnkbuf[0] = '\0';
569		pathlen = 0;
570		getfile(xtrlnkfile, xtrlnkskip);
571		if (pathlen == 0) {
572			vprintf(stdout,
573			    "%s: zero length symbolic link (ignored)\n", name);
574			return (GOOD);
575		}
576		return (linkit(lnkbuf, name, SYMLINK));
577
578	case IFIFO:
579		vprintf(stdout, "extract fifo %s\n", name);
580		if (Nflag) {
581			skipfile();
582			return (GOOD);
583		}
584		if (uflag && !Nflag)
585			(void)unlink(name);
586		if (mkfifo(name, mode) < 0) {
587			fprintf(stderr, "%s: cannot create fifo: %s\n",
588			    name, strerror(errno));
589			skipfile();
590			return (FAIL);
591		}
592		(void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid);
593		(void) chmod(name, mode);
594		utimes(name, timep);
595		(void) chflags(name, flags);
596		skipfile();
597		return (GOOD);
598
599	case IFCHR:
600	case IFBLK:
601		vprintf(stdout, "extract special file %s\n", name);
602		if (Nflag) {
603			skipfile();
604			return (GOOD);
605		}
606		if (uflag)
607			(void)unlink(name);
608		if (mknod(name, mode, (int)curfile.dip->di_rdev) < 0) {
609			fprintf(stderr, "%s: cannot create special file: %s\n",
610			    name, strerror(errno));
611			skipfile();
612			return (FAIL);
613		}
614		(void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid);
615		(void) chmod(name, mode);
616		utimes(name, timep);
617		(void) chflags(name, flags);
618		skipfile();
619		return (GOOD);
620
621	case IFREG:
622		vprintf(stdout, "extract file %s\n", name);
623		if (Nflag) {
624			skipfile();
625			return (GOOD);
626		}
627		if (uflag)
628			(void)unlink(name);
629		if ((ofile = open(name, O_WRONLY | O_CREAT | O_TRUNC,
630		    0666)) < 0) {
631			fprintf(stderr, "%s: cannot create file: %s\n",
632			    name, strerror(errno));
633			skipfile();
634			return (FAIL);
635		}
636		(void) fchown(ofile, curfile.dip->di_uid, curfile.dip->di_gid);
637		(void) fchmod(ofile, mode);
638		getfile(xtrfile, xtrskip);
639		(void) close(ofile);
640		utimes(name, timep);
641		(void) chflags(name, flags);
642		return (GOOD);
643	}
644	/* NOTREACHED */
645}
646
647/*
648 * skip over bit maps on the tape
649 */
650void
651skipmaps(void)
652{
653
654	while (spcl.c_type == TS_BITS || spcl.c_type == TS_CLRI)
655		skipfile();
656}
657
658/*
659 * skip over a file on the tape
660 */
661void
662skipfile(void)
663{
664
665	curfile.action = SKIP;
666	getfile(xtrnull, xtrnull);
667}
668
669/*
670 * Extract a file from the tape.
671 * When an allocated block is found it is passed to the fill function;
672 * when an unallocated block (hole) is found, a zeroed buffer is passed
673 * to the skip function.
674 */
675void
676getfile(void (*fill)(char *, long), void (*skip)(char *, long))
677{
678	int i;
679	int curblk = 0;
680	quad_t size = spcl.c_dinode.di_size;
681	static char clearedbuf[MAXBSIZE];
682	char buf[MAXBSIZE / TP_BSIZE][TP_BSIZE];
683	char junk[TP_BSIZE];
684
685	if (spcl.c_type == TS_END)
686		panic("ran off end of tape\n");
687	if (spcl.c_magic != NFS_MAGIC)
688		panic("not at beginning of a file\n");
689	if (!gettingfile && setjmp(restart) != 0)
690		return;
691	gettingfile++;
692loop:
693	for (i = 0; i < spcl.c_count; i++) {
694		if (readmapflag || spcl.c_addr[i]) {
695			readtape(&buf[curblk++][0]);
696			if (curblk == fssize / TP_BSIZE) {
697				(*fill)((char *)buf, (long)(size > TP_BSIZE ?
698				     fssize : (curblk - 1) * TP_BSIZE + size));
699				curblk = 0;
700			}
701		} else {
702			if (curblk > 0) {
703				(*fill)((char *)buf, (long)(size > TP_BSIZE ?
704				     curblk * TP_BSIZE :
705				     (curblk - 1) * TP_BSIZE + size));
706				curblk = 0;
707			}
708			(*skip)(clearedbuf, (long)(size > TP_BSIZE ?
709				TP_BSIZE : size));
710		}
711		if ((size -= TP_BSIZE) <= 0) {
712			for (i++; i < spcl.c_count; i++)
713				if (readmapflag || spcl.c_addr[i])
714					readtape(junk);
715			break;
716		}
717	}
718	if (gethead(&spcl) == GOOD && size > 0) {
719		if (spcl.c_type == TS_ADDR)
720			goto loop;
721		dprintf(stdout,
722			"Missing address (header) block for %s at %ld blocks\n",
723			curfile.name, blksread);
724	}
725	if (curblk > 0)
726		(*fill)((char *)buf, (long)((curblk * TP_BSIZE) + size));
727	findinode(&spcl);
728	gettingfile = 0;
729}
730
731/*
732 * Write out the next block of a file.
733 */
734static void
735xtrfile(char *buf, long	size)
736{
737
738	if (Nflag)
739		return;
740	if (write(ofile, buf, (int) size) == -1) {
741		fprintf(stderr,
742		    "write error extracting inode %d, name %s\nwrite: %s\n",
743			curfile.ino, curfile.name, strerror(errno));
744	}
745}
746
747/*
748 * Skip over a hole in a file.
749 */
750/* ARGSUSED */
751static void
752xtrskip(char *buf, long size)
753{
754
755	if (lseek(ofile, size, SEEK_CUR) == -1) {
756		fprintf(stderr,
757		    "seek error extracting inode %d, name %s\nlseek: %s\n",
758			curfile.ino, curfile.name, strerror(errno));
759		done(1);
760	}
761}
762
763/*
764 * Collect the next block of a symbolic link.
765 */
766static void
767xtrlnkfile(char *buf, long size)
768{
769
770	pathlen += size;
771	if (pathlen > MAXPATHLEN) {
772		fprintf(stderr, "symbolic link name: %s->%s%s; too long %d\n",
773		    curfile.name, lnkbuf, buf, pathlen);
774		done(1);
775	}
776	(void) strcat(lnkbuf, buf);
777}
778
779/*
780 * Skip over a hole in a symbolic link (should never happen).
781 */
782/* ARGSUSED */
783static void
784xtrlnkskip(char *buf, long size)
785{
786
787	fprintf(stderr, "unallocated block in symbolic link %s\n",
788		curfile.name);
789	done(1);
790}
791
792/*
793 * Collect the next block of a bit map.
794 */
795static void
796xtrmap(char *buf, long size)
797{
798
799	memmove(map, buf, size);
800	map += size;
801}
802
803/*
804 * Skip over a hole in a bit map (should never happen).
805 */
806/* ARGSUSED */
807static void
808xtrmapskip(char *buf, long size)
809{
810
811	panic("hole in map\n");
812	map += size;
813}
814
815/*
816 * Noop, when an extraction function is not needed.
817 */
818/* ARGSUSED */
819void
820xtrnull(char *buf, long size)
821{
822
823	return;
824}
825
826/*
827 * Read TP_BSIZE blocks from the input.
828 * Handle read errors, and end of media.
829 */
830static void
831readtape(char *buf)
832{
833	long rd, newvol, i;
834	int cnt, seek_failed;
835
836	if (blkcnt < numtrec) {
837		memmove(buf, &tapebuf[(blkcnt++ * TP_BSIZE)], (long)TP_BSIZE);
838		blksread++;
839		tapeaddr++;
840		return;
841	}
842	for (i = 0; i < ntrec; i++)
843		((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
844	if (numtrec == 0)
845		numtrec = ntrec;
846	cnt = ntrec * TP_BSIZE;
847	rd = 0;
848getmore:
849#ifdef RRESTORE
850	if (host)
851		i = rmtread(&tapebuf[rd], cnt);
852	else
853#endif
854		i = read(mt, &tapebuf[rd], cnt);
855	/*
856	 * Check for mid-tape short read error.
857	 * If found, skip rest of buffer and start with the next.
858	 */
859	if (!pipein && numtrec < ntrec && i > 0) {
860		dprintf(stdout, "mid-media short read error.\n");
861		numtrec = ntrec;
862	}
863	/*
864	 * Handle partial block read.
865	 */
866	if (pipein && i == 0 && rd > 0)
867		i = rd;
868	else if (i > 0 && i != ntrec * TP_BSIZE) {
869		if (pipein) {
870			rd += i;
871			cnt -= i;
872			if (cnt > 0)
873				goto getmore;
874			i = rd;
875		} else {
876			/*
877			 * Short read. Process the blocks read.
878			 */
879			if (i % TP_BSIZE != 0)
880				vprintf(stdout,
881				    "partial block read: %ld should be %ld\n",
882				    i, ntrec * TP_BSIZE);
883			numtrec = i / TP_BSIZE;
884		}
885	}
886	/*
887	 * Handle read error.
888	 */
889	if (i < 0) {
890		fprintf(stderr, "Tape read error while ");
891		switch (curfile.action) {
892		default:
893			fprintf(stderr, "trying to set up tape\n");
894			break;
895		case UNKNOWN:
896			fprintf(stderr, "trying to resynchronize\n");
897			break;
898		case USING:
899			fprintf(stderr, "restoring %s\n", curfile.name);
900			break;
901		case SKIP:
902			fprintf(stderr, "skipping over inode %d\n",
903				curfile.ino);
904			break;
905		}
906		if (!yflag && !reply("continue"))
907			done(1);
908		i = ntrec * TP_BSIZE;
909		memset(tapebuf, 0, i);
910#ifdef RRESTORE
911		if (host)
912			seek_failed = (rmtseek(i, 1) < 0);
913		else
914#endif
915			seek_failed = (lseek(mt, i, SEEK_CUR) == (off_t)-1);
916
917		if (seek_failed) {
918			fprintf(stderr,
919			    "continuation failed: %s\n", strerror(errno));
920			done(1);
921		}
922	}
923	/*
924	 * Handle end of tape.
925	 */
926	if (i == 0) {
927		vprintf(stdout, "End-of-tape encountered\n");
928		if (!pipein) {
929			newvol = volno + 1;
930			volno = 0;
931			numtrec = 0;
932			getvol(newvol);
933			readtape(buf);
934			return;
935		}
936		if (rd % TP_BSIZE != 0)
937			panic("partial block read: %d should be %d\n",
938				rd, ntrec * TP_BSIZE);
939		terminateinput();
940		memmove(&tapebuf[rd], &endoftapemark, (long)TP_BSIZE);
941	}
942	blkcnt = 0;
943	memmove(buf, &tapebuf[(blkcnt++ * TP_BSIZE)], (long)TP_BSIZE);
944	blksread++;
945	tapeaddr++;
946}
947
948static void
949findtapeblksize(void)
950{
951	long i;
952
953	for (i = 0; i < ntrec; i++)
954		((struct s_spcl *)&tapebuf[i * TP_BSIZE])->c_magic = 0;
955	blkcnt = 0;
956#ifdef RRESTORE
957	if (host)
958		i = rmtread(tapebuf, ntrec * TP_BSIZE);
959	else
960#endif
961		i = read(mt, tapebuf, ntrec * TP_BSIZE);
962
963	if (i <= 0) {
964		fprintf(stderr, "tape read error: %s\n", strerror(errno));
965		done(1);
966	}
967	if (i % TP_BSIZE != 0) {
968		fprintf(stderr, "Tape block size (%ld) %s (%d)\n",
969			i, "is not a multiple of dump block size", TP_BSIZE);
970		done(1);
971	}
972	ntrec = i / TP_BSIZE;
973	numtrec = ntrec;
974	vprintf(stdout, "Tape block size is %ld\n", ntrec);
975}
976
977void
978closemt(void)
979{
980
981	if (mt < 0)
982		return;
983#ifdef RRESTORE
984	if (host)
985		rmtclose();
986	else
987#endif
988		(void) close(mt);
989}
990
991/*
992 * Read the next block from the tape.
993 * Check to see if it is one of several vintage headers.
994 * If it is an old style header, convert it to a new style header.
995 * If it is not any valid header, return an error.
996 */
997static int
998gethead(struct s_spcl *buf)
999{
1000	long i;
1001	union {
1002		quad_t	qval;
1003		int32_t	val[2];
1004	} qcvt;
1005	union u_ospcl {
1006		char dummy[TP_BSIZE];
1007		struct	s_ospcl {
1008			int32_t	c_type;
1009			int32_t	c_date;
1010			int32_t	c_ddate;
1011			int32_t	c_volume;
1012			int32_t	c_tapea;
1013			u_short	c_inumber;
1014			int32_t	c_magic;
1015			int32_t	c_checksum;
1016			struct odinode {
1017				unsigned short odi_mode;
1018				u_short	odi_nlink;
1019				u_short	odi_uid;
1020				u_short	odi_gid;
1021				int32_t	odi_size;
1022				int32_t	odi_rdev;
1023				char	odi_addr[36];
1024				int32_t	odi_atime;
1025				int32_t	odi_mtime;
1026				int32_t	odi_ctime;
1027			} c_dinode;
1028			int32_t	c_count;
1029			char	c_addr[256];
1030		} s_ospcl;
1031	} u_ospcl;
1032
1033	if (!cvtflag) {
1034		readtape((char *)buf);
1035		if (buf->c_magic != NFS_MAGIC) {
1036			if (swabl(buf->c_magic) != NFS_MAGIC)
1037				return (FAIL);
1038			if (!Bcvt) {
1039				vprintf(stdout, "Note: Doing Byte swapping\n");
1040				Bcvt = 1;
1041			}
1042		}
1043		if (checksum((int *)buf) == FAIL)
1044			return (FAIL);
1045		if (Bcvt) {
1046			swabst((u_char *)"8l4s31l", (u_char *)buf);
1047			swabst((u_char *)"l",(u_char *) &buf->c_level);
1048			swabst((u_char *)"2l",(u_char *) &buf->c_flags);
1049		}
1050		goto good;
1051	}
1052	readtape((char *)(&u_ospcl.s_ospcl));
1053	memset(buf, 0, (long)TP_BSIZE);
1054	buf->c_type = u_ospcl.s_ospcl.c_type;
1055	buf->c_date = u_ospcl.s_ospcl.c_date;
1056	buf->c_ddate = u_ospcl.s_ospcl.c_ddate;
1057	buf->c_volume = u_ospcl.s_ospcl.c_volume;
1058	buf->c_tapea = u_ospcl.s_ospcl.c_tapea;
1059	buf->c_inumber = u_ospcl.s_ospcl.c_inumber;
1060	buf->c_checksum = u_ospcl.s_ospcl.c_checksum;
1061	buf->c_magic = u_ospcl.s_ospcl.c_magic;
1062	buf->c_dinode.di_mode = u_ospcl.s_ospcl.c_dinode.odi_mode;
1063	buf->c_dinode.di_nlink = u_ospcl.s_ospcl.c_dinode.odi_nlink;
1064	buf->c_dinode.di_uid = u_ospcl.s_ospcl.c_dinode.odi_uid;
1065	buf->c_dinode.di_gid = u_ospcl.s_ospcl.c_dinode.odi_gid;
1066	buf->c_dinode.di_size = u_ospcl.s_ospcl.c_dinode.odi_size;
1067	buf->c_dinode.di_rdev = u_ospcl.s_ospcl.c_dinode.odi_rdev;
1068	buf->c_dinode.di_atime = u_ospcl.s_ospcl.c_dinode.odi_atime;
1069	buf->c_dinode.di_mtime = u_ospcl.s_ospcl.c_dinode.odi_mtime;
1070	buf->c_dinode.di_ctime = u_ospcl.s_ospcl.c_dinode.odi_ctime;
1071	buf->c_count = u_ospcl.s_ospcl.c_count;
1072	memmove(buf->c_addr, u_ospcl.s_ospcl.c_addr, (long)256);
1073	if (u_ospcl.s_ospcl.c_magic != OFS_MAGIC ||
1074	    checksum((int *)(&u_ospcl.s_ospcl)) == FAIL)
1075		return(FAIL);
1076	buf->c_magic = NFS_MAGIC;
1077
1078good:
1079	if ((buf->c_dinode.di_size == 0 || buf->c_dinode.di_size > 0xfffffff) &&
1080	    (buf->c_dinode.di_mode & IFMT) == IFDIR && Qcvt == 0) {
1081		qcvt.qval = buf->c_dinode.di_size;
1082		if (qcvt.val[0] || qcvt.val[1]) {
1083			printf("Note: Doing Quad swapping\n");
1084			Qcvt = 1;
1085		}
1086	}
1087	if (Qcvt) {
1088		qcvt.qval = buf->c_dinode.di_size;
1089		i = qcvt.val[1];
1090		qcvt.val[1] = qcvt.val[0];
1091		qcvt.val[0] = i;
1092		buf->c_dinode.di_size = qcvt.qval;
1093	}
1094	readmapflag = 0;
1095
1096	switch (buf->c_type) {
1097
1098	case TS_CLRI:
1099	case TS_BITS:
1100		/*
1101		 * Have to patch up missing information in bit map headers
1102		 */
1103		buf->c_inumber = 0;
1104		buf->c_dinode.di_size = buf->c_count * TP_BSIZE;
1105		if (buf->c_count > TP_NINDIR)
1106			readmapflag = 1;
1107		else
1108			for (i = 0; i < buf->c_count; i++)
1109				buf->c_addr[i]++;
1110		break;
1111
1112	case TS_TAPE:
1113		if ((buf->c_flags & DR_NEWINODEFMT) == 0)
1114			oldinofmt = 1;
1115		/* fall through */
1116	case TS_END:
1117		buf->c_inumber = 0;
1118		break;
1119
1120	case TS_INODE:
1121	case TS_ADDR:
1122		break;
1123
1124	default:
1125		panic("gethead: unknown inode type %d\n", buf->c_type);
1126		break;
1127	}
1128	/*
1129	 * If we are restoring a filesystem with old format inodes,
1130	 * copy the uid/gid to the new location.
1131	 */
1132	if (oldinofmt) {
1133		buf->c_dinode.di_uid = buf->c_dinode.di_ouid;
1134		buf->c_dinode.di_gid = buf->c_dinode.di_ogid;
1135	}
1136	tapeaddr = buf->c_tapea;
1137	if (dflag)
1138		accthdr(buf);
1139	return(GOOD);
1140}
1141
1142/*
1143 * Check that a header is where it belongs and predict the next header
1144 */
1145static void
1146accthdr(struct s_spcl *header)
1147{
1148	static ino_t previno = 0x7fffffff;
1149	static int prevtype;
1150	static long predict;
1151	long blks, i;
1152
1153	if (header->c_type == TS_TAPE) {
1154		fprintf(stderr, "Volume header (%s inode format) ",
1155		    oldinofmt ? "old" : "new");
1156 		if (header->c_firstrec)
1157 			fprintf(stderr, "begins with record %ld",
1158 				header->c_firstrec);
1159 		fprintf(stderr, "\n");
1160		previno = 0x7fffffff;
1161		return;
1162	}
1163	if (previno == 0x7fffffff)
1164		goto newcalc;
1165	switch (prevtype) {
1166	case TS_BITS:
1167		fprintf(stderr, "Dumped inodes map header");
1168		break;
1169	case TS_CLRI:
1170		fprintf(stderr, "Used inodes map header");
1171		break;
1172	case TS_INODE:
1173		fprintf(stderr, "File header, ino %d", previno);
1174		break;
1175	case TS_ADDR:
1176		fprintf(stderr, "File continuation header, ino %d", previno);
1177		break;
1178	case TS_END:
1179		fprintf(stderr, "End of tape header");
1180		break;
1181	}
1182	if (predict != blksread - 1)
1183		fprintf(stderr, "; predicted %ld blocks, got %ld blocks",
1184			predict, blksread - 1);
1185	fprintf(stderr, "\n");
1186newcalc:
1187	blks = 0;
1188	if (header->c_type != TS_END)
1189		for (i = 0; i < header->c_count; i++)
1190			if (readmapflag || header->c_addr[i] != 0)
1191				blks++;
1192	predict = blks;
1193	blksread = 0;
1194	prevtype = header->c_type;
1195	previno = header->c_inumber;
1196}
1197
1198/*
1199 * Find an inode header.
1200 * Complain if had to skip.
1201 */
1202static void
1203findinode(struct s_spcl *header)
1204{
1205	static long skipcnt = 0;
1206	long i;
1207	char buf[TP_BSIZE];
1208	int htype;
1209
1210	curfile.name = "<name unknown>";
1211	curfile.action = UNKNOWN;
1212	curfile.dip = NULL;
1213	curfile.ino = 0;
1214	do {
1215		if (header->c_magic != NFS_MAGIC) {
1216			skipcnt++;
1217			while (gethead(header) == FAIL ||
1218			    _time32_to_time(header->c_date) != dumpdate)
1219				skipcnt++;
1220		}
1221		htype = header->c_type;
1222		switch (htype) {
1223
1224		case TS_ADDR:
1225			/*
1226			 * Skip up to the beginning of the next record
1227			 */
1228			for (i = 0; i < header->c_count; i++)
1229				if (header->c_addr[i])
1230					readtape(buf);
1231			while (gethead(header) == FAIL ||
1232			    _time32_to_time(header->c_date) != dumpdate)
1233				skipcnt++;
1234			break;
1235
1236		case TS_INODE:
1237			curfile.dip = &header->c_dinode;
1238			curfile.ino = header->c_inumber;
1239			break;
1240
1241		case TS_END:
1242			/* If we missed some tapes, get another volume. */
1243			if (tapesread & (tapesread + 1)) {
1244				getvol(0);
1245				continue;
1246			}
1247			curfile.ino = maxino;
1248			break;
1249
1250		case TS_CLRI:
1251			curfile.name = "<file removal list>";
1252			break;
1253
1254		case TS_BITS:
1255			curfile.name = "<file dump list>";
1256			break;
1257
1258		case TS_TAPE:
1259			panic("unexpected tape header\n");
1260			/* NOTREACHED */
1261
1262		default:
1263			panic("unknown tape header type %d\n", spcl.c_type);
1264			/* NOTREACHED */
1265
1266		}
1267	} while (htype == TS_ADDR);
1268	if (skipcnt > 0)
1269		fprintf(stderr, "resync restore, skipped %ld blocks\n",
1270		    skipcnt);
1271	skipcnt = 0;
1272}
1273
1274static int
1275checksum(int *buf)
1276{
1277	int i, j;
1278
1279	j = sizeof(union u_spcl) / sizeof(int);
1280	i = 0;
1281	if(!Bcvt) {
1282		do
1283			i += *buf++;
1284		while (--j);
1285	} else {
1286		/* What happens if we want to read restore tapes
1287			for a 16bit int machine??? */
1288		do
1289			i += swabl(*buf++);
1290		while (--j);
1291	}
1292
1293	if (i != CHECKSUM) {
1294		fprintf(stderr, "Checksum error %o, inode %d file %s\n", i,
1295			curfile.ino, curfile.name);
1296		return(FAIL);
1297	}
1298	return(GOOD);
1299}
1300
1301#ifdef RRESTORE
1302#include <stdarg.h>
1303
1304void
1305msg(const char *fmt, ...)
1306{
1307	va_list ap;
1308	va_start(ap, fmt);
1309	(void)vfprintf(stderr, fmt, ap);
1310	va_end(ap);
1311}
1312#endif /* RRESTORE */
1313
1314static u_char *
1315swabshort(u_char *sp, int n)
1316{
1317	char c;
1318
1319	while (--n >= 0) {
1320		c = sp[0]; sp[0] = sp[1]; sp[1] = c;
1321		sp += 2;
1322	}
1323	return (sp);
1324}
1325
1326static u_char *
1327swablong(u_char *sp, int n)
1328{
1329	char c;
1330
1331	while (--n >= 0) {
1332		c = sp[0]; sp[0] = sp[3]; sp[3] = c;
1333		c = sp[2]; sp[2] = sp[1]; sp[1] = c;
1334		sp += 4;
1335	}
1336	return (sp);
1337}
1338
1339void
1340swabst(u_char *cp, u_char *sp)
1341{
1342	int n = 0;
1343
1344	while (*cp) {
1345		switch (*cp) {
1346		case '0': case '1': case '2': case '3': case '4':
1347		case '5': case '6': case '7': case '8': case '9':
1348			n = (n * 10) + (*cp++ - '0');
1349			continue;
1350
1351		case 's': case 'w': case 'h':
1352			if (n == 0)
1353				n = 1;
1354			sp = swabshort(sp, n);
1355			break;
1356
1357		case 'l':
1358			if (n == 0)
1359				n = 1;
1360			sp = swablong(sp, n);
1361			break;
1362
1363		default: /* Any other character, like 'b' counts as byte. */
1364			if (n == 0)
1365				n = 1;
1366			sp += n;
1367			break;
1368		}
1369		cp++;
1370		n = 0;
1371	}
1372}
1373
1374static u_long
1375swabl(u_long x)
1376{
1377	swabst((u_char *)"l", (u_char *)&x);
1378	return (x);
1379}
1380