[unix-history] / usr / src / old / tp / tp2.c

#ifndef lint
static char sccsid[] = "@(#)tp2.c	4.1 %G%";
#endif

#include "tp.h"
#include <stdio.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/dir.h>

struct stat	statb;

clrdir()
{
	register j, *p;

	j = ndirent * (DIRSZ/sizeof(int));
	p = (int *)dir;
	do (*p++ = 0);  while (--j);
	lastd = 0;
}

clrent(ptr)
struct	dent *ptr;
{
	register *p, j;

	p  = (int *)ptr;
	j = DIRSZ/sizeof(int);
	do *p++ = 0;
	   while (--j);
	if (++ptr == lastd) do {
		if (--lastd < dir) {
			lastd = 0;
			return;
		}
	} while (lastd->d_namep == 0);
}


rddir()
{
	register struct tent *tp;
	register struct dent *p1;
	struct dent  *dptr;
	struct tent  *tptr;
	int	count, i, sum;
	short	reg, *sp;

	sum = 0;
	clrdir();
	rseek(0);
	tread();	/* Read the bootstrap block */
	if ((tpentry[TPB-1].cksum != 0) && (flags & flm)) {
		ndirent = tpentry[TPB-1].cksum;
		if(flags & fls) swab((char *)&ndirent, (char *)&ndirent, sizeof(ndirent));
		if(ndirent < 0 || ndirent > MDIRENT) ndirent = MDIRENT;
		ndentb = ndirent/TPB;
	}
	dptr = &dir[0];
	count = ndirent;
	do {
		if ((count % TPB) == 0) {	/* next block */
			tread();
			tptr = &tpentry[0];
		}
		if(flags & fls)
			swab((char *)tptr, (char *)tptr, sizeof(*tptr));
		sp = (short *)tptr;
		reg = 0;
		for(i=0;i<sizeof(struct tent)/sizeof(short);i++)
			reg += *sp++;
		if(flags & fls) {
			swab((char *)tptr, (char *)tptr, sizeof(*tptr));
			swabdir(tptr);
		}
		sum |= reg;
		p1 = dptr;
		if (reg == 0) {
			tp = tptr;
			if(tp->pathnam[0] != '\0') {
				lastd = p1;
				encode(tp->pathnam,p1);
				p1->d_mode = tp->mode;
				p1->d_uid = tp->uid;
				p1->d_gid = tp->gid;
				p1->d_size = (((long)tp->size0&0377L)<<16)+(tp->size1&0177777L);
				p1->d_time = tp->time;
				p1->d_tapea = tp->tapea;
			}
		}
		++tptr;		/* bump to next tent */
		(dptr++)->d_mode &= ~OK;
	} while (--count);
	if(sum != 0)
		if(flags & (fls|fli)) {
			printf("Directory checksum\n");
			if ((flags & fli) == 0)		done();
		} else {
			flags |= fls;
			rddir();
			printf("Warning: swabbing required\n");
			return;
		}
	bitmap();
}


wrdir()
{
	register struct tent *tp;
	register struct dent *dp;
	struct dent *dptr;
	int	count, i;
	short	reg, *sp;

	wseek(0);
	if (flags & flm)
		reg = open(mheader,0);
	else	reg = open(theader,0);
	if (reg >= 0) {
		read(reg,(char *)tapeb,BSIZE);
		close(reg);
		if(flags & fls)
			swab((char *)&ndirent, (char *)&tpentry[TPB-1].cksum, sizeof(ndirent));
		else
			tpentry[TPB-1].cksum = ndirent;
	} else
		printf("\7\7\7Warning: cannot read prototype boot block.\n");
	dptr = &dir[0];
	count = ndirent;
	for (;;) {
		twrite();
		if (count == 0)  return;
		tp = &tpentry[0];
		do {
			dp = dptr++;	/* dptr set to next entry */
			if (dp->d_namep)  {
				decode(tp->pathnam,dp);
				tp->mode = dp->d_mode;
				tp->uid = dp->d_uid;
				tp->gid = dp->d_gid;
				tp->time = dp->d_time;
				tp->size0 = dp->d_size >> 16;
				tp->size1 = dp->d_size;
				tp->tapea = dp->d_tapea;
				if(flags & fls) {
					swabdir(tp);
					swab((char *)tp, (char *)tp, sizeof(*tp));
				}
				reg = 0;
				sp = (short *)tp;
				for(i=0;i<sizeof(struct tent)/sizeof(short)-1;i++)
					reg -= *sp++;
				*sp = reg;
				if(flags & fls)
					swab((char *)tp, (char *)tp, sizeof(*tp));
			} else {
				sp = (short *)tp;
				for(i=0;i<sizeof(struct tent)/sizeof(short);i++)
					*sp++ = 0;
			}
		tp++;
		} while (--count % TPB);
	}
}

tread()
{
	register j, *ptr;

	if (read(fio,(char *)tapeb,BSIZE) != BSIZE) {
		printf("Tape read error\n");
		if ((flags & fli) == 0)		done();
		ptr = (int *)tapeb;
		j = BSIZE/sizeof(int);
		while(j--) *ptr++ = 0;
	}
	rseeka++;
}

twrite()
{
	if (write(fio, (char *)tapeb,BSIZE) != BSIZE) {
		printf("Tape write error\n");
		done();
	}
	++wseeka;
}

rseek(blk)
{
	rseeka = blk;
	if (lseek(fio,(long)blk*BSIZE,0) < 0)	seekerr();
}

wseek(blk)
{
	register amt, b;

	amt = b = blk;
	if ((amt -= wseeka) < 0)	amt = -amt;
	if (amt > 25 && b) {
		lseek(fio, (long)(b-1)*BSIZE, 0);	/* seek previous block */
		read(fio, (char *)&wseeka, 1);  /* read next block */
	}
	wseeka = b;
	if (lseek(fio, (long)b*BSIZE, 0) < 0)	seekerr();
}

seekerr()
{
	printf("Tape seek error\n");
	done();
}

verify(key)
{
	register c;

	if ((flags & (flw | flv)) == 0)
		return(0);
repeat:	printf("%c %s ", key, name);
	if ((flags & flw) == 0) {
		printf("\n");
		return(0);
	}
	c = getchar();
	if (c == 'n' && getchar() == '\n')
		done();
	if (c == '\n')
		return(-1);
	if (c == 'y' && getchar() == '\n')
		return(0);
	while (getchar() != '\n');
	goto repeat;
}

getfiles()
{

	if ((narg -= 2) == 0) {
		strcpy(name, ".");
		callout();
	} else while (--narg >= 0) {
		strcpy(name, *parg++);
		callout();
	}
}


expand()
{
	register  char *p0, *save0;
	int n;
	register DIR *dirp;
	struct direct *dirent;

	if ((dirp = opendir(name)) == NULL)	fserr();
	for (;;) {
		dirent = readdir(dirp);
		if (dirent == NULL) {
			closedir(dirp);
			return;
		}
		if (dirent->d_ino == 0)	/* null entry */
			continue;
		p0 = name;
		if (dirent->d_name[0] == '.')		/* don't save .xxxx */
			continue;
		while (*p0++);
		save0 = --p0;		/* save loc of \0 */
		if (p0[-1] != '/')
			*p0++ = '/';
		strcpy(p0, dirent->d_name);
			callout();
		*save0 = 0;		/* restore */
	}
}

fserr()
{
	printf("%s -- Cannot open file\n", name);
	done();
}

callout()
{
	register struct dent *d;
	register char *ptr1, *ptr0;
	struct dent *empty;
	int mode;

	if (stat(name,&statb) < 0)	fserr();
	mode = statb.st_mode;
	if ((mode &= S_IFMT) != 0) {
		if (mode == S_IFDIR)  /* directory */
			expand();
		if(mode != S_IFREG) return;
	}
	/* when we reach here we have recursed until we found 
	 * an ordinary file.  Now we look for it in "dir".
	 */
	empty = 0;
	d = &dir[0];
	do  {
		if (d->d_namep == 0) {	/* empty directory slot */
			if (empty == 0) /* remember the first one */
				empty = d;
			continue;
		}
		decode(name1,d);
		ptr0 = name;
		ptr1 = name1;
		do	if (*ptr0++ != *ptr1)   goto cont;
		    while (*ptr1++);
		/* veritably the same name */
		if (flags & flu) {  /* check the times */
			if (d->d_time >= statb.st_mtime)
				return;
		}
		if (verify('r') < 0)	return;
		goto copydir;
cont:		continue;
	}  while (++d <= lastd);
	/* name not found in directory */
	if ((d = empty) == 0) {
		d = lastd +1;
		if (d >= edir) {
			printf("Directory overflow\n");
			done();
		}
	}
	if (verify('a') < 0)		return;
	if (d > lastd)		lastd = d;
	encode(name,d);
copydir:
	d->d_mode = statb.st_mode | OK;
	d->d_uid = statb.st_uid;
	d->d_gid = statb.st_gid;
	d->d_size = statb.st_size;
	d->d_time = statb.st_mtime;
	;
}

swabdir(tp)
register struct tent *tp;
{
	swab((char *)tp, (char *)tp, sizeof(*tp));
	swab(tp->pathnam, tp->pathnam, NAMELEN);
	swab((char *)&tp->uid, (char *)&tp->uid, 4); /* uid,gid,spare,size0 */
}
Commit	Line	Data
cc4bd1b0 SL	1	#ifndef lint
	2	static char sccsid[] = "@(#)tp2.c 4.1 %G%";
	3	#endif
	4
	5	#include "tp.h"
	6	#include <stdio.h>
	7	#include <sys/param.h>
	8	#include <sys/stat.h>
	9	#include <sys/dir.h>
	10
	11	struct stat statb;
	12
	13	clrdir()
	14	{
	15	register j, *p;
	16
	17	j = ndirent * (DIRSZ/sizeof(int));
	18	p = (int *)dir;
	19	do (*p++ = 0); while (--j);
	20	lastd = 0;
	21	}
	22
	23	clrent(ptr)
	24	struct dent *ptr;
	25	{
	26	register *p, j;
	27
	28	p = (int *)ptr;
	29	j = DIRSZ/sizeof(int);
	30	do *p++ = 0;
	31	while (--j);
	32	if (++ptr == lastd) do {
	33	if (--lastd < dir) {
	34	lastd = 0;
	35	return;
	36	}
	37	} while (lastd->d_namep == 0);
	38	}
	39
	40
	41	rddir()
	42	{
	43	register struct tent *tp;
	44	register struct dent *p1;
	45	struct dent *dptr;
	46	struct tent *tptr;
	47	int count, i, sum;
	48	short reg, *sp;
	49
	50	sum = 0;
	51	clrdir();
	52	rseek(0);
	53	tread(); /* Read the bootstrap block */
	54	if ((tpentry[TPB-1].cksum != 0) && (flags & flm)) {
	55	ndirent = tpentry[TPB-1].cksum;
	56	if(flags & fls) swab((char )&ndirent, (char )&ndirent, sizeof(ndirent));
	57	if(ndirent < 0 \|\| ndirent > MDIRENT) ndirent = MDIRENT;
	58	ndentb = ndirent/TPB;
	59	}
	60	dptr = &dir[0];
	61	count = ndirent;
	62	do {
	63	if ((count % TPB) == 0) { /* next block */
	64	tread();
65	tptr = &tpentry[0];
66	}
67	if(flags & fls)
68	swab((char )tptr, (char )tptr, sizeof(*tptr));
69	sp = (short *)tptr;
70	reg = 0;
71	for(i=0;i<sizeof(struct tent)/sizeof(short);i++)
72	reg += *sp++;
73	if(flags & fls) {
74	swab((char )tptr, (char )tptr, sizeof(*tptr));
75	swabdir(tptr);
76	}
77	sum \|= reg;
78	p1 = dptr;
79	if (reg == 0) {
80	tp = tptr;
81	if(tp->pathnam[0] != '\0') {
82	lastd = p1;
83	encode(tp->pathnam,p1);
84	p1->d_mode = tp->mode;
85	p1->d_uid = tp->uid;
86	p1->d_gid = tp->gid;
87	p1->d_size = (((long)tp->size0&0377L)<<16)+(tp->size1&0177777L);
88	p1->d_time = tp->time;
89	p1->d_tapea = tp->tapea;
90	}
91	}
92	++tptr; /* bump to next tent */
93	(dptr++)->d_mode &= ~OK;
94	} while (--count);
95	if(sum != 0)
96	if(flags & (fls\|fli)) {
97	printf("Directory checksum\n");
98	if ((flags & fli) == 0) done();
99	} else {
100	flags \|= fls;
101	rddir();
102	printf("Warning: swabbing required\n");
103	return;
104	}
105	bitmap();
106	}
107
108
109	wrdir()
110	{
111	register struct tent *tp;
112	register struct dent *dp;
113	struct dent *dptr;
114	int count, i;
115	short reg, *sp;
116
117	wseek(0);
118	if (flags & flm)
119	reg = open(mheader,0);
120	else reg = open(theader,0);
121	if (reg >= 0) {
122	read(reg,(char *)tapeb,BSIZE);
123	close(reg);
124	if(flags & fls)
125	swab((char )&ndirent, (char )&tpentry[TPB-1].cksum, sizeof(ndirent));
126	else
127	tpentry[TPB-1].cksum = ndirent;
128	} else
129	printf("\7\7\7Warning: cannot read prototype boot block.\n");
130	dptr = &dir[0];
131	count = ndirent;
132	for (;;) {
133	twrite();
134	if (count == 0) return;
135	tp = &tpentry[0];
136	do {
137	dp = dptr++; /* dptr set to next entry */
138	if (dp->d_namep) {
139	decode(tp->pathnam,dp);
140	tp->mode = dp->d_mode;
141	tp->uid = dp->d_uid;
142	tp->gid = dp->d_gid;
143	tp->time = dp->d_time;
144	tp->size0 = dp->d_size >> 16;
145	tp->size1 = dp->d_size;
146	tp->tapea = dp->d_tapea;
147	if(flags & fls) {
148	swabdir(tp);
149	swab((char )tp, (char )tp, sizeof(*tp));
150	}
151	reg = 0;
152	sp = (short *)tp;
153	for(i=0;i<sizeof(struct tent)/sizeof(short)-1;i++)
154	reg -= *sp++;
155	*sp = reg;
156	if(flags & fls)
157	swab((char )tp, (char )tp, sizeof(*tp));
158	} else {
159	sp = (short *)tp;
160	for(i=0;i<sizeof(struct tent)/sizeof(short);i++)
161	*sp++ = 0;
162	}
163	tp++;
164	} while (--count % TPB);
165	}
166	}
167
168	tread()
169	{
170	register j, *ptr;
171
172	if (read(fio,(char *)tapeb,BSIZE) != BSIZE) {
173	printf("Tape read error\n");
174	if ((flags & fli) == 0) done();
175	ptr = (int *)tapeb;
176	j = BSIZE/sizeof(int);
177	while(j--) *ptr++ = 0;
178	}
179	rseeka++;
180	}
181
182	twrite()
183	{
184	if (write(fio, (char *)tapeb,BSIZE) != BSIZE) {
185	printf("Tape write error\n");
186	done();
187	}
188	++wseeka;
189	}
190
191	rseek(blk)
192	{
193	rseeka = blk;
194	if (lseek(fio,(long)blk*BSIZE,0) < 0) seekerr();
195	}
196
197	wseek(blk)
198	{
199	register amt, b;
200
201	amt = b = blk;
202	if ((amt -= wseeka) < 0) amt = -amt;
203	if (amt > 25 && b) {
204	lseek(fio, (long)(b-1)BSIZE, 0); / seek previous block */
205	read(fio, (char )&wseeka, 1); / read next block */
206	}
207	wseeka = b;
208	if (lseek(fio, (long)b*BSIZE, 0) < 0) seekerr();
209	}
210
211	seekerr()
212	{
213	printf("Tape seek error\n");
214	done();
215	}
216
217	verify(key)
218	{
219	register c;
220
221	if ((flags & (flw \| flv)) == 0)
222	return(0);
223	repeat: printf("%c %s ", key, name);
224	if ((flags & flw) == 0) {
225	printf("\n");
226	return(0);
227	}
228	c = getchar();
229	if (c == 'n' && getchar() == '\n')
230	done();
231	if (c == '\n')
232	return(-1);
233	if (c == 'y' && getchar() == '\n')
234	return(0);
235	while (getchar() != '\n');
236	goto repeat;
237	}
238
239	getfiles()
240	{
241
242	if ((narg -= 2) == 0) {
243	strcpy(name, ".");
244	callout();
245	} else while (--narg >= 0) {
246	strcpy(name, *parg++);
247	callout();
248	}
249	}
250
251
252	expand()
253	{
254	register char p0, save0;
255	int n;
256	register DIR *dirp;
257	struct direct *dirent;
258
259	if ((dirp = opendir(name)) == NULL) fserr();
260	for (;;) {
261	dirent = readdir(dirp);
262	if (dirent == NULL) {
263	closedir(dirp);
264	return;
265	}
266	if (dirent->d_ino == 0) /* null entry */
267	continue;
268	p0 = name;
269	if (dirent->d_name[0] == '.') /* don't save .xxxx */
270	continue;
271	while (*p0++);
272	save0 = --p0; /* save loc of \0 */
273	if (p0[-1] != '/')
274	*p0++ = '/';
275	strcpy(p0, dirent->d_name);
276	callout();
277	save0 = 0; / restore */
278	}
279	}
280
281	fserr()
282	{
283	printf("%s -- Cannot open file\n", name);
284	done();
285	}
286
287	callout()
288	{
289	register struct dent *d;
290	register char ptr1, ptr0;
291	struct dent *empty;
292	int mode;
293
294	if (stat(name,&statb) < 0) fserr();
295	mode = statb.st_mode;
296	if ((mode &= S_IFMT) != 0) {
297	if (mode == S_IFDIR) /* directory */
298	expand();
299	if(mode != S_IFREG) return;
300	}
301	/* when we reach here we have recursed until we found
302	* an ordinary file. Now we look for it in "dir".
303	*/
304	empty = 0;
305	d = &dir[0];
306	do {
307	if (d->d_namep == 0) { /* empty directory slot */
308	if (empty == 0) /* remember the first one */
309	empty = d;
310	continue;
311	}
312	decode(name1,d);
313	ptr0 = name;
314	ptr1 = name1;
315	do if (ptr0++ != ptr1) goto cont;
316	while (*ptr1++);
317	/* veritably the same name */
318	if (flags & flu) { /* check the times */
319	if (d->d_time >= statb.st_mtime)
320	return;
321	}
322	if (verify('r') < 0) return;
323	goto copydir;
324	cont: continue;
325	} while (++d <= lastd);
326	/* name not found in directory */
327	if ((d = empty) == 0) {
328	d = lastd +1;
329	if (d >= edir) {
330	printf("Directory overflow\n");
331	done();
332	}
333	}
334	if (verify('a') < 0) return;
335	if (d > lastd) lastd = d;
336	encode(name,d);
337	copydir:
338	d->d_mode = statb.st_mode \| OK;
339	d->d_uid = statb.st_uid;
340	d->d_gid = statb.st_gid;
341	d->d_size = statb.st_size;
342	d->d_time = statb.st_mtime;
343	;
344	}
345
346	swabdir(tp)
347	register struct tent *tp;
348	{
349	swab((char )tp, (char )tp, sizeof(*tp));
350	swab(tp->pathnam, tp->pathnam, NAMELEN);
351	swab((char )&tp->uid, (char )&tp->uid, 4); /* uid,gid,spare,size0 */
352	}