[unix-history] / usr / src / cmd / dumpdir.c

#define MAXINO	3000
#define BITS	8
#define MAXXTR	60
#define NCACHE	3

#include <stdio.h>
#include <sys/param.h>
#include <sys/inode.h>
#include <sys/ino.h>
#include <sys/fblk.h>
#include <sys/filsys.h>
#include <sys/dir.h>
#include <dumprestor.h>

#define	MWORD(m,i) (m[(unsigned)(i-1)/MLEN])
#define	MBIT(i)	(1<<((unsigned)(i-1)%MLEN))
#define	BIS(i,w)	(MWORD(w,i) |=  MBIT(i))
#define	BIC(i,w)	(MWORD(w,i) &= ~MBIT(i))
#define	BIT(i,w)	(MWORD(w,i) & MBIT(i))

int	mt;
char	tapename[] = "/dev/rmt1";
char	*magtape = tapename;

daddr_t	seekpt;
int	ofile;
FILE	*df;
char	dirfile[] = "rstXXXXXX";

struct {
	ino_t	t_ino;
	daddr_t	t_seekpt;
} inotab[MAXINO];
int	ipos;

#define ONTAPE	1
#define XTRACTD	2
#define XINUSE	4

short	dumpmap[MSIZ];
short	clrimap[MSIZ];


int bct = NTREC+1;
char tbf[NTREC*BSIZE];

char prebuf[512];

int volno;

main(argc, argv)
char *argv[];
{
	extern char *ctime();

	mktemp(dirfile);
	argv++;
	if (argc>=3 && *argv[0] == 'f')
		magtape = *++argv;
	df = fopen(dirfile, "w");
	if (df == NULL) {
		printf("dumpdir: %s - cannot create directory temporary\n", dirfile);
		exit(1);
	}

	if ((mt = open(magtape, 0)) < 0) {
		printf("%s: cannot open tape\n", magtape);
		exit(1);
	}
	if (readhdr(&spcl) == 0) {
		printf("Tape is not a dump tape\n");
		exit(1);
	}
	printf("Dump   date: %s", ctime(&spcl.c_date));
	printf("Dumped from: %s", ctime(&spcl.c_ddate));
	if (checkvol(&spcl, 1) == 0) {
		printf("Tape is not volume 1 of the dump\n");
		exit(1);
	}
	pass1();  /* This sets the various maps on the way by */
	freopen(dirfile, "r", df);
	strcpy(prebuf, "/");
	printem(prebuf, (ino_t) 2);
	exit(0);
}
	i = 0;
/*
 * Read the tape, bulding up a directory structure for extraction
 * by name
 */
pass1()
{
	register i;
	struct dinode *ip;
	int	putdir(), null();

	while (gethead(&spcl) == 0) {
		printf("Can't find directory header!\n");
	}
	for (;;) {
		if (checktype(&spcl, TS_BITS) == 1) {
			readbits(dumpmap);
			continue;
		}
		if (checktype(&spcl, TS_CLRI) == 1) {
			readbits(clrimap);
			continue;
		}
		if (checktype(&spcl, TS_INODE) == 0) {
finish:
			flsh();
			close(mt);
			return;
		}
		ip = &spcl.c_dinode;
		i = ip->di_mode & IFMT;
		if (i != IFDIR) {
			goto finish;
		}
		inotab[ipos].t_ino = spcl.c_inumber;
		inotab[ipos++].t_seekpt = seekpt;
		getfile(spcl.c_inumber, putdir, null, spcl.c_dinode.di_size);
		putent("\000\000/");
	}
}

printem(prefix, inum)
char *prefix;
ino_t	inum;
{
	struct direct dir;
	register int i;

	for (i = 0; i < MAXINO; i++)
		if (inotab[i].t_ino == inum) {
			goto found;
		}
	printf("PANIC - can't find directory %d\n", inum);
	return;
found:
	mseek(inotab[i].t_seekpt);
	for (;;) {
		getent((char *) &dir);
		if (direq(dir.d_name, "/"))
			return;
		if (search(dir.d_ino) != 0 && direq(dir.d_name, ".") == 0 && direq(dir.d_name, "..") == 0) {
			int len;
			FILE *tdf;

			tdf = df;
			df = fopen(dirfile, "r");
			len = strlen(prefix);
			strncat(prefix, dir.d_name, sizeof(dir.d_name));
			strcat(prefix, "/");
			printem(prefix, dir.d_ino);
			prefix[len] = '\0';
			fclose(df);
			df = tdf;
		}
		else
			if (BIT(dir.d_ino, dumpmap))
				printf("%5d	%s%-.14s\n", dir.d_ino, prefix, dir.d_name);
	}
}
/*
 * Do the file extraction, calling the supplied functions
 * with the blocks
 */
getfile(n, f1, f2, size)
ino_t	n;
int	(*f2)(), (*f1)();
long	size;
{
	register i;
	struct spcl addrblock;
	char buf[BSIZE];

	addrblock = spcl;
	goto start;
	for (;;) {
		if (gethead(&addrblock) == 0) {
			printf("Missing address (header) block\n");
			goto eloop;
		}
		if (checktype(&addrblock, TS_ADDR) == 0) {
			spcl = addrblock;
			return;
		}
start:
		for (i = 0; i < addrblock.c_count; i++) {
			if (addrblock.c_addr[i]) {
				readtape(buf);
				(*f1)(buf, size > BSIZE ? (long) BSIZE : size);
			}
			else {
				clearbuf(buf);
				(*f2)(buf, size > BSIZE ? (long) BSIZE : size);
			}
			if ((size -= BSIZE) <= 0) {
eloop:
				while (gethead(&spcl) == 0)
					;
				if (checktype(&spcl, TS_ADDR) == 1)
					goto eloop;
				return;
			}
		}
	}
}

/*
 * Do the tape i\/o, dealling with volume changes
 * etc..
 */
readtape(b)
char *b;
{
	register i;
	struct spcl tmpbuf;

	if (bct >= NTREC) {
		for (i = 0; i < NTREC; i++)
			((struct spcl *)&tbf[i*BSIZE])->c_magic = 0;
		bct = 0;
		if ((i = read(mt, tbf, NTREC*BSIZE)) < 0) {
			exit(1);
		}
		if (i == 0) {
			bct = NTREC + 1;
			volno++;
loop:
			flsht();
			close(mt);
			printf("Mount volume %d\n", volno);
			while (getchar() != '\n')
				;
			if ((mt = open(magtape, 0)) == -1) {
				printf("Cannot open tape!\n");
			}
			if (readhdr(&tmpbuf) == 0) {
				printf("Not a dump tape.Try again\n");
				goto loop;
			}
			if (checkvol(&tmpbuf, volno) == 0) {
				printf("Wrong tape. Try again\n");
				goto loop;
			}
			readtape(b);
			return;
		}
	}
	copy(&tbf[(bct++*BSIZE)], b, BSIZE);
}

flsht()
{
	bct = NTREC+1;
}

copy(f, t, s)
register char *f, *t;
{
	register i;

	i = s;
	do
		*t++ = *f++;
	while (--i);
}

clearbuf(cp)
register char *cp;
{
	register i;

	i = BSIZE;
	do
		*cp++ = 0;
	while (--i);
}

/*
 * Put and get the directory entries from the compressed
 * directory file
 */
putent(cp)
char	*cp;
{
	register i;

	for (i = 0; i < sizeof(ino_t); i++)
		writec(*cp++);
	for (i = 0; i < DIRSIZ; i++) {
		writec(*cp);
		if (*cp++ == 0)
			return;
	}
	return;
}

getent(bf)
register char *bf;
{
	register i;

	for (i = 0; i < sizeof(ino_t); i++)
		*bf++ = readc();
	for (i = 0; i < DIRSIZ; i++)
		if ((*bf++ = readc()) == 0)
			return;
	return;
}

/*
 * read/write te directory file
 */
writec(c)
char c;
{
	seekpt++;
	fwrite(&c, 1, 1, df);
}

readc()
{
	char c;

	fread(&c, 1, 1, df);
	return(c);
}

mseek(pt)
daddr_t pt;
{
	fseek(df, pt, 0);
}

flsh()
{
	fflush(df);
}

/*
 * search the directory inode ino
 * looking for entry cp
 */
search(inum)
ino_t	inum;
{
	register low, high, probe;

	low = 0;
	high = ipos-1;

	while (low != high) {
		probe = (high - low + 1)/2 + low;
/*
printf("low = %d, high = %d, probe = %d, ino = %d, inum = %d\n", low, high, probe, inum, inotab[probe].t_ino);
*/
		if (inum >= inotab[probe].t_ino)
			low = probe;
		else
			high = probe - 1;
	}
	return(inum == inotab[low].t_ino);
}

direq(s1, s2)
register char *s1, *s2;
{
	register i;

	for (i = 0; i < DIRSIZ; i++)
		if (*s1++ == *s2) {
			if (*s2++ == 0)
				return(1);
		} else
			return(0);
	return(1);
}

/*
 * read the tape into buf, then return whether or
 * or not it is a header block.
 */
gethead(buf)
struct spcl *buf;
{
	readtape((char *)buf);
	if (buf->c_magic != MAGIC || checksum((int *) buf) == 0)
		return(0);
	return(1);
}

/*
 * return whether or not the buffer contains a header block
 */
checktype(b, t)
struct	spcl *b;
int	t;
{
	return(b->c_type == t);
}


checksum(b)
int *b;
{
	register i, j;

	j = BSIZE/sizeof(int);
	i = 0;
	do
		i += *b++;
	while (--j);
	if (i != CHECKSUM) {
		printf("Checksum error %o\n", i);
		return(0);
	}
	return(1);
}

checkvol(b, t)
struct spcl *b;
int t;
{
	if (b->c_volume == t)
		return(1);
	return(0);
}

readhdr(b)
struct	spcl *b;
{
	if (gethead(b) == 0)
		return(0);
	if (checktype(b, TS_TAPE) == 0)
		return(0);
	return(1);
}

putdir(b)
char *b;
{
	register struct direct *dp;
	register i;

	for (dp = (struct direct *) b, i = 0; i < BSIZE; dp++, i += sizeof(*dp)) {
		if (dp->d_ino == 0)
			continue;
		putent((char *) dp);
	}
}

/*
 * read a bit mask from the tape into m.
 */
readbits(m)
short	*m;
{
	register i;

	i = spcl.c_count;

	while (i--) {
		readtape((char *) m);
		m += (BSIZE/(MLEN/BITS));
	}
	while (gethead(&spcl) == 0)
		;
}

null() { ; }
Commit	Line	Data
80936526 KT	1	#define MAXINO 3000
	2	#define BITS 8
	3	#define MAXXTR 60
	4	#define NCACHE 3
	5
	6	#include <stdio.h>
	7	#include <sys/param.h>
	8	#include <sys/inode.h>
	9	#include <sys/ino.h>
	10	#include <sys/fblk.h>
	11	#include <sys/filsys.h>
	12	#include <sys/dir.h>
	13	#include <dumprestor.h>
	14
	15	#define MWORD(m,i) (m[(unsigned)(i-1)/MLEN])
	16	#define MBIT(i) (1<<((unsigned)(i-1)%MLEN))
	17	#define BIS(i,w) (MWORD(w,i) \|= MBIT(i))
	18	#define BIC(i,w) (MWORD(w,i) &= ~MBIT(i))
	19	#define BIT(i,w) (MWORD(w,i) & MBIT(i))
	20
	21	int mt;
	22	char tapename[] = "/dev/rmt1";
	23	char *magtape = tapename;
	24
	25	daddr_t seekpt;
	26	int ofile;
	27	FILE *df;
	28	char dirfile[] = "rstXXXXXX";
	29
	30	struct {
	31	ino_t t_ino;
	32	daddr_t t_seekpt;
	33	} inotab[MAXINO];
	34	int ipos;
	35
	36	#define ONTAPE 1
	37	#define XTRACTD 2
	38	#define XINUSE 4
	39
	40	short dumpmap[MSIZ];
	41	short clrimap[MSIZ];
	42
	43
	44	int bct = NTREC+1;
	45	char tbf[NTREC*BSIZE];
	46
	47	char prebuf[512];
	48
	49	int volno;
	50
	51	main(argc, argv)
	52	char *argv[];
	53	{
	54	extern char *ctime();
	55
	56	mktemp(dirfile);
	57	argv++;
	58	if (argc>=3 && *argv[0] == 'f')
	59	magtape = *++argv;
	60	df = fopen(dirfile, "w");
	61	if (df == NULL) {
	62	printf("dumpdir: %s - cannot create directory temporary\n", dirfile);
	63	exit(1);
	64	}
65
66	if ((mt = open(magtape, 0)) < 0) {
67	printf("%s: cannot open tape\n", magtape);
68	exit(1);
69	}
70	if (readhdr(&spcl) == 0) {
71	printf("Tape is not a dump tape\n");
72	exit(1);
73	}
74	printf("Dump date: %s", ctime(&spcl.c_date));
75	printf("Dumped from: %s", ctime(&spcl.c_ddate));
76	if (checkvol(&spcl, 1) == 0) {
77	printf("Tape is not volume 1 of the dump\n");
78	exit(1);
79	}
80	pass1(); /* This sets the various maps on the way by */
81	freopen(dirfile, "r", df);
82	strcpy(prebuf, "/");
83	printem(prebuf, (ino_t) 2);
84	exit(0);
85	}
86	i = 0;
87	/*
88	* Read the tape, bulding up a directory structure for extraction
89	* by name
90	*/
91	pass1()
92	{
93	register i;
94	struct dinode *ip;
95	int putdir(), null();
96
97	while (gethead(&spcl) == 0) {
98	printf("Can't find directory header!\n");
99	}
100	for (;;) {
101	if (checktype(&spcl, TS_BITS) == 1) {
102	readbits(dumpmap);
103	continue;
104	}
105	if (checktype(&spcl, TS_CLRI) == 1) {
106	readbits(clrimap);
107	continue;
108	}
109	if (checktype(&spcl, TS_INODE) == 0) {
110	finish:
111	flsh();
112	close(mt);
113	return;
114	}
115	ip = &spcl.c_dinode;
116	i = ip->di_mode & IFMT;
117	if (i != IFDIR) {
118	goto finish;
119	}
120	inotab[ipos].t_ino = spcl.c_inumber;
121	inotab[ipos++].t_seekpt = seekpt;
122	getfile(spcl.c_inumber, putdir, null, spcl.c_dinode.di_size);
123	putent("\000\000/");
124	}
125	}
126
127	printem(prefix, inum)
128	char *prefix;
129	ino_t inum;
130	{
131	struct direct dir;
132	register int i;
133
134	for (i = 0; i < MAXINO; i++)
135	if (inotab[i].t_ino == inum) {
136	goto found;
137	}
138	printf("PANIC - can't find directory %d\n", inum);
139	return;
140	found:
141	mseek(inotab[i].t_seekpt);
142	for (;;) {
143	getent((char *) &dir);
144	if (direq(dir.d_name, "/"))
145	return;
146	if (search(dir.d_ino) != 0 && direq(dir.d_name, ".") == 0 && direq(dir.d_name, "..") == 0) {
147	int len;
148	FILE *tdf;
149
150	tdf = df;
151	df = fopen(dirfile, "r");
152	len = strlen(prefix);
153	strncat(prefix, dir.d_name, sizeof(dir.d_name));
154	strcat(prefix, "/");
155	printem(prefix, dir.d_ino);
156	prefix[len] = '\0';
157	fclose(df);
158	df = tdf;
159	}
160	else
161	if (BIT(dir.d_ino, dumpmap))
162	printf("%5d %s%-.14s\n", dir.d_ino, prefix, dir.d_name);
163	}
164	}
165	/*
166	* Do the file extraction, calling the supplied functions
167	* with the blocks
168	*/
169	getfile(n, f1, f2, size)
170	ino_t n;
171	int (f2)(), (f1)();
172	long size;
173	{
174	register i;
175	struct spcl addrblock;
176	char buf[BSIZE];
177
178	addrblock = spcl;
179	goto start;
180	for (;;) {
181	if (gethead(&addrblock) == 0) {
182	printf("Missing address (header) block\n");
183	goto eloop;
184	}
185	if (checktype(&addrblock, TS_ADDR) == 0) {
186	spcl = addrblock;
187	return;
188	}
189	start:
190	for (i = 0; i < addrblock.c_count; i++) {
191	if (addrblock.c_addr[i]) {
192	readtape(buf);
193	(*f1)(buf, size > BSIZE ? (long) BSIZE : size);
194	}
195	else {
196	clearbuf(buf);
197	(*f2)(buf, size > BSIZE ? (long) BSIZE : size);
198	}
199	if ((size -= BSIZE) <= 0) {
200	eloop:
201	while (gethead(&spcl) == 0)
202	;
203	if (checktype(&spcl, TS_ADDR) == 1)
204	goto eloop;
205	return;
206	}
207	}
208	}
209	}
210
211	/*
212	* Do the tape i\/o, dealling with volume changes
213	* etc..
214	*/
215	readtape(b)
216	char *b;
217	{
218	register i;
219	struct spcl tmpbuf;
220
221	if (bct >= NTREC) {
222	for (i = 0; i < NTREC; i++)
223	((struct spcl )&tbf[iBSIZE])->c_magic = 0;
224	bct = 0;
225	if ((i = read(mt, tbf, NTREC*BSIZE)) < 0) {
226	exit(1);
227	}
228	if (i == 0) {
229	bct = NTREC + 1;
230	volno++;
231	loop:
232	flsht();
233	close(mt);
234	printf("Mount volume %d\n", volno);
235	while (getchar() != '\n')
236	;
237	if ((mt = open(magtape, 0)) == -1) {
238	printf("Cannot open tape!\n");
239	}
240	if (readhdr(&tmpbuf) == 0) {
241	printf("Not a dump tape.Try again\n");
242	goto loop;
243	}
244	if (checkvol(&tmpbuf, volno) == 0) {
245	printf("Wrong tape. Try again\n");
246	goto loop;
247	}
248	readtape(b);
249	return;
250	}
251	}
252	copy(&tbf[(bct++*BSIZE)], b, BSIZE);
253	}
254
255	flsht()
256	{
257	bct = NTREC+1;
258	}
259
260	copy(f, t, s)
261	register char f, t;
262	{
263	register i;
264
265	i = s;
266	do
267	t++ = f++;
268	while (--i);
269	}
270
271	clearbuf(cp)
272	register char *cp;
273	{
274	register i;
275
276	i = BSIZE;
277	do
278	*cp++ = 0;
279	while (--i);
280	}
281
282	/*
283	* Put and get the directory entries from the compressed
284	* directory file
285	*/
286	putent(cp)
287	char *cp;
288	{
289	register i;
290
291	for (i = 0; i < sizeof(ino_t); i++)
292	writec(*cp++);
293	for (i = 0; i < DIRSIZ; i++) {
294	writec(*cp);
295	if (*cp++ == 0)
296	return;
297	}
298	return;
299	}
300
301	getent(bf)
302	register char *bf;
303	{
304	register i;
305
306	for (i = 0; i < sizeof(ino_t); i++)
307	*bf++ = readc();
308	for (i = 0; i < DIRSIZ; i++)
309	if ((*bf++ = readc()) == 0)
310	return;
311	return;
312	}
313
314	/*
315	* read/write te directory file
316	*/
317	writec(c)
318	char c;
319	{
320	seekpt++;
321	fwrite(&c, 1, 1, df);
322	}
323
324	readc()
325	{
326	char c;
327
328	fread(&c, 1, 1, df);
329	return(c);
330	}
331
332	mseek(pt)
333	daddr_t pt;
334	{
335	fseek(df, pt, 0);
336	}
337
338	flsh()
339	{
340	fflush(df);
341	}
342
343	/*
344	* search the directory inode ino
345	* looking for entry cp
346	*/
347	search(inum)
348	ino_t inum;
349	{
350	register low, high, probe;
351
352	low = 0;
353	high = ipos-1;
354
355	while (low != high) {
356	probe = (high - low + 1)/2 + low;
357	/*
358	printf("low = %d, high = %d, probe = %d, ino = %d, inum = %d\n", low, high, probe, inum, inotab[probe].t_ino);
359	*/
360	if (inum >= inotab[probe].t_ino)
361	low = probe;
362	else
363	high = probe - 1;
364	}
365	return(inum == inotab[low].t_ino);
366	}
367
368	direq(s1, s2)
369	register char s1, s2;
370	{
371	register i;
372
373	for (i = 0; i < DIRSIZ; i++)
374	if (s1++ == s2) {
375	if (*s2++ == 0)
376	return(1);
377	} else
378	return(0);
379	return(1);
380	}
381
382	/*
383	* read the tape into buf, then return whether or
384	* or not it is a header block.
385	*/
386	gethead(buf)
387	struct spcl *buf;
388	{
389	readtape((char *)buf);
390	if (buf->c_magic != MAGIC \|\| checksum((int *) buf) == 0)
391	return(0);
392	return(1);
393	}
394
395	/*
396	* return whether or not the buffer contains a header block
397	*/
398	checktype(b, t)
399	struct spcl *b;
400	int t;
401	{
402	return(b->c_type == t);
403	}
404
405
406	checksum(b)
407	int *b;
408	{
409	register i, j;
410
411	j = BSIZE/sizeof(int);
412	i = 0;
413	do
414	i += *b++;
415	while (--j);
416	if (i != CHECKSUM) {
417	printf("Checksum error %o\n", i);
418	return(0);
419	}
420	return(1);
421	}
422
423	checkvol(b, t)
424	struct spcl *b;
425	int t;
426	{
427	if (b->c_volume == t)
428	return(1);
429	return(0);
430	}
431
432	readhdr(b)
433	struct spcl *b;
434	{
435	if (gethead(b) == 0)
436	return(0);
437	if (checktype(b, TS_TAPE) == 0)
438	return(0);
439	return(1);
440	}
441
442	putdir(b)
443	char *b;
444	{
445	register struct direct *dp;
446	register i;
447
448	for (dp = (struct direct ) b, i = 0; i < BSIZE; dp++, i += sizeof(dp)) {
449	if (dp->d_ino == 0)
450	continue;
451	putent((char *) dp);
452	}
453	}
454
455	/*
456	* read a bit mask from the tape into m.
457	*/
458	readbits(m)
459	short *m;
460	{
461	register i;
462
463	i = spcl.c_count;
464
465	while (i--) {
466	readtape((char *) m);
467	m += (BSIZE/(MLEN/BITS));
468	}
469	while (gethead(&spcl) == 0)
470	;
471	}
472
473	null() { ; }