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

/*
 * ncheck -- obtain file names from reading filesystem
 */

#define	NI	16
#define	NB	100
#define	HSIZE	2503
#define	NDIR	(BSIZE/sizeof(struct direct))

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

struct	filsys	sblock;
struct	dinode	itab[INOPB*NI];
daddr_t	iaddr[NADDR];
ino_t	ilist[NB];
struct	htab
{
	ino_t	h_ino;
	ino_t	h_pino;
	char	h_name[DIRSIZ];
} htab[HSIZE];

int	aflg;
int	sflg;
int	fi;
ino_t	ino;
int	nhent;
int	nxfile;

int	nerror;
daddr_t	bmap();
long	atol();
struct htab *lookup();

main(argc, argv)
char *argv[];
{
	register i;
	long n;

	while (--argc) {
		argv++;
		if (**argv=='-')
		switch ((*argv)[1]) {

		case 'a':
			aflg++;
			continue;

		case 'i':
			for(i=0; i<NB; i++) {
				n = atol(argv[1]);
				if(n == 0)
					break;
				ilist[i] = n;
				nxfile = i;
				argv++;
				argc--;
			}
			continue;

		case 's':
			sflg++;
			continue;

		default:
			fprintf(stderr, "ncheck: bad flag %c\n", (*argv)[1]);
			nerror++;
		}
		check(*argv);
	}
	return(nerror);
}

check(file)
char *file;
{
	register i, j;
	ino_t mino;

	fi = open(file, 0);
	if(fi < 0) {
		fprintf(stderr, "ncheck: cannot open %s\n", file);
		nerror++;
		return;
	}
	nhent = 0;
	printf("%s:\n", file);
	sync();
	bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
	mino = (sblock.s_isize-2) * INOPB;
	ino = 0;
	for(i=2;; i+=NI) {
		if(ino >= mino)
			break;
		bread((daddr_t)i, (char *)itab, sizeof(itab));
		for(j=0; j<INOPB*NI; j++) {
			if(ino >= mino)
				break;
			ino++;
			pass1(&itab[j]);
		}
	}
	ilist[nxfile+1] = 0;
	ino = 0;
	for(i=2;; i+=NI) {
		if(ino >= mino)
			break;
		bread((daddr_t)i, (char *)itab, sizeof(itab));
		for(j=0; j<INOPB*NI; j++) {
			if(ino >= mino)
				break;
			ino++;
			pass2(&itab[j]);
		}
	}
	ino = 0;
	for(i=2;; i+=NI) {
		if(ino >= mino)
			break;
		bread((daddr_t)i, (char *)itab, sizeof(itab));
		for(j=0; j<INOPB*NI; j++) {
			if(ino >= mino)
				break;
			ino++;
			pass3(&itab[j]);
		}
	}
}

pass1(ip)
register struct dinode *ip;
{
	if((ip->di_mode & IFMT) != IFDIR) {
		if (sflg==0 || nxfile>=NB)
			return;
		if ((ip->di_mode&IFMT)==IFBLK || (ip->di_mode&IFMT)==IFCHR
		  || ip->di_mode&(ISUID|ISGID))
			ilist[nxfile++] = ino;
			return;
	}
	lookup(ino, 1);
}

pass2(ip)
register struct dinode *ip;
{
	struct direct dbuf[NDIR];
	long doff;
	struct direct *dp;
	register i, j;
	int k;
	struct htab *hp;
	daddr_t d;
	ino_t kno;

	if((ip->di_mode&IFMT) != IFDIR)
		return;
	l3tol(iaddr, ip->di_addr, NADDR);
	doff = 0;
	for(i=0;; i++) {
		if(doff >= ip->di_size)
			break;
		d = bmap(i);
		if(d == 0)
			break;
		bread(d, (char *)dbuf, sizeof(dbuf));
		for(j=0; j<NDIR; j++) {
			if(doff >= ip->di_size)
				break;
			doff += sizeof(struct direct);
			dp = dbuf+j;
			kno = dp->d_ino;
			if(kno == 0)
				continue;
			hp = lookup(kno, 0);
			if(hp == 0)
				continue;
			if(dotname(dp))
				continue;
			hp->h_pino = ino;
			for(k=0; k<DIRSIZ; k++)
				hp->h_name[k] = dp->d_name[k];
		}
	}
}

pass3(ip)
register struct dinode *ip;
{
	struct direct dbuf[NDIR];
	long doff;
	struct direct *dp;
	register i, j;
	int k;
	daddr_t d;
	ino_t kno;

	if((ip->di_mode&IFMT) != IFDIR)
		return;
	l3tol(iaddr, ip->di_addr, NADDR);
	doff = 0;
	for(i=0;; i++) {
		if(doff >= ip->di_size)
			break;
		d = bmap(i);
		if(d == 0)
			break;
		bread(d, (char *)dbuf, sizeof(dbuf));
		for(j=0; j<NDIR; j++) {
			if(doff >= ip->di_size)
				break;
			doff += sizeof(struct direct);
			dp = dbuf+j;
			kno = dp->d_ino;
			if(kno == 0)
				continue;
			if(aflg==0 && dotname(dp))
				continue;
			if(ilist[0] == 0)
				goto pr;
			for(k=0; ilist[k] != 0; k++)
				if(ilist[k] == kno)
					goto pr;
			continue;
		pr:
			printf("%u	", kno);
			pname(ino, 0);
			printf("/%.14s", dp->d_name);
			if (lookup(kno, 0))
				printf("/.");
			printf("\n");
		}
	}
}

dotname(dp)
register struct direct *dp;
{

	if (dp->d_name[0]=='.')
		if (dp->d_name[1]==0 || (dp->d_name[1]=='.' && dp->d_name[2]==0))
			return(1);
	return(0);
}

pname(i, lev)
ino_t i;
{
	register struct htab *hp;

	if (i==ROOTINO)
		return;
	if ((hp = lookup(i, 0)) == 0) {
		printf("???");
		return;
	}
	if (lev > 10) {
		printf("...");
		return;
	}
	pname(hp->h_pino, ++lev);
	printf("/%.14s", hp->h_name);
}

struct htab *
lookup(i, ef)
ino_t i;
{
	register struct htab *hp;

	for (hp = &htab[i%HSIZE]; hp->h_ino;) {
		if (hp->h_ino==i)
			return(hp);
		if (++hp >= &htab[HSIZE])
			hp = htab;
	}
	if (ef==0)
		return(0);
	if (++nhent >= HSIZE) {
		fprintf(stderr, "ncheck: out of core-- increase HSIZE\n");
		exit(1);
	}
	hp->h_ino = i;
	return(hp);
}

bread(bno, buf, cnt)
daddr_t bno;
char *buf;
{
	register i;

	lseek(fi, bno*BSIZE, 0);
	if (read(fi, buf, cnt) != cnt) {
		fprintf(stderr, "ncheck: read error %d\n", bno);
		for(i=0; i<BSIZE; i++)
			buf[i] = 0;
	}
}

daddr_t
bmap(i)
{
	daddr_t ibuf[NINDIR];

	if(i < NADDR-3)
		return(iaddr[i]);
	i -= NADDR-3;
	if(i > NINDIR) {
		fprintf(stderr, "ncheck: %u - huge directory\n", ino);
		return((daddr_t)0);
	}
	bread(iaddr[NADDR-3], (char *)ibuf, sizeof(ibuf));
	return(ibuf[i]);
}
Commit	Line	Data
f6897333 TL	1	/*
	2	* ncheck -- obtain file names from reading filesystem
	3	*/
	4
	5	#define NI 16
	6	#define NB 100
	7	#define HSIZE 2503
	8	#define NDIR (BSIZE/sizeof(struct direct))
	9
	10	#include <stdio.h>
	11	#include <sys/param.h>
	12	#include <sys/inode.h>
	13	#include <sys/ino.h>
	14	#include <sys/dir.h>
	15	#include <sys/filsys.h>
	16	#include <sys/fblk.h>
	17
	18	struct filsys sblock;
	19	struct dinode itab[INOPB*NI];
	20	daddr_t iaddr[NADDR];
	21	ino_t ilist[NB];
	22	struct htab
	23	{
	24	ino_t h_ino;
	25	ino_t h_pino;
	26	char h_name[DIRSIZ];
	27	} htab[HSIZE];
	28
	29	int aflg;
	30	int sflg;
	31	int fi;
	32	ino_t ino;
	33	int nhent;
	34	int nxfile;
	35
	36	int nerror;
	37	daddr_t bmap();
	38	long atol();
	39	struct htab *lookup();
	40
	41	main(argc, argv)
	42	char *argv[];
	43	{
	44	register i;
	45	long n;
	46
	47	while (--argc) {
	48	argv++;
	49	if (**argv=='-')
	50	switch ((*argv)[1]) {
	51
	52	case 'a':
	53	aflg++;
	54	continue;
	55
	56	case 'i':
	57	for(i=0; i<NB; i++) {
	58	n = atol(argv[1]);
	59	if(n == 0)
	60	break;
	61	ilist[i] = n;
	62	nxfile = i;
	63	argv++;
	64	argc--;
65	}
66	continue;
67
68	case 's':
69	sflg++;
70	continue;
71
72	default:
73	fprintf(stderr, "ncheck: bad flag %c\n", (*argv)[1]);
74	nerror++;
75	}
76	check(*argv);
77	}
78	return(nerror);
79	}
80
81	check(file)
82	char *file;
83	{
84	register i, j;
85	ino_t mino;
86
87	fi = open(file, 0);
88	if(fi < 0) {
89	fprintf(stderr, "ncheck: cannot open %s\n", file);
90	nerror++;
91	return;
92	}
93	nhent = 0;
94	printf("%s:\n", file);
95	sync();
96	bread((daddr_t)1, (char *)&sblock, sizeof(sblock));
97	mino = (sblock.s_isize-2) * INOPB;
98	ino = 0;
99	for(i=2;; i+=NI) {
100	if(ino >= mino)
101	break;
102	bread((daddr_t)i, (char *)itab, sizeof(itab));
103	for(j=0; j<INOPB*NI; j++) {
104	if(ino >= mino)
105	break;
106	ino++;
107	pass1(&itab[j]);
108	}
109	}
110	ilist[nxfile+1] = 0;
111	ino = 0;
112	for(i=2;; i+=NI) {
113	if(ino >= mino)
114	break;
115	bread((daddr_t)i, (char *)itab, sizeof(itab));
116	for(j=0; j<INOPB*NI; j++) {
117	if(ino >= mino)
118	break;
119	ino++;
120	pass2(&itab[j]);
121	}
122	}
123	ino = 0;
124	for(i=2;; i+=NI) {
125	if(ino >= mino)
126	break;
127	bread((daddr_t)i, (char *)itab, sizeof(itab));
128	for(j=0; j<INOPB*NI; j++) {
129	if(ino >= mino)
130	break;
131	ino++;
132	pass3(&itab[j]);
133	}
134	}
135	}
136
137	pass1(ip)
138	register struct dinode *ip;
139	{
140	if((ip->di_mode & IFMT) != IFDIR) {
141	if (sflg==0 \|\| nxfile>=NB)
142	return;
143	if ((ip->di_mode&IFMT)==IFBLK \|\| (ip->di_mode&IFMT)==IFCHR
144	\|\| ip->di_mode&(ISUID\|ISGID))
145	ilist[nxfile++] = ino;
146	return;
147	}
148	lookup(ino, 1);
149	}
150
151	pass2(ip)
152	register struct dinode *ip;
153	{
154	struct direct dbuf[NDIR];
155	long doff;
156	struct direct *dp;
157	register i, j;
158	int k;
159	struct htab *hp;
160	daddr_t d;
161	ino_t kno;
162
163	if((ip->di_mode&IFMT) != IFDIR)
164	return;
165	l3tol(iaddr, ip->di_addr, NADDR);
166	doff = 0;
167	for(i=0;; i++) {
168	if(doff >= ip->di_size)
169	break;
170	d = bmap(i);
171	if(d == 0)
172	break;
173	bread(d, (char *)dbuf, sizeof(dbuf));
174	for(j=0; j<NDIR; j++) {
175	if(doff >= ip->di_size)
176	break;
177	doff += sizeof(struct direct);
178	dp = dbuf+j;
179	kno = dp->d_ino;
180	if(kno == 0)
181	continue;
182	hp = lookup(kno, 0);
183	if(hp == 0)
184	continue;
185	if(dotname(dp))
186	continue;
187	hp->h_pino = ino;
188	for(k=0; k<DIRSIZ; k++)
189	hp->h_name[k] = dp->d_name[k];
190	}
191	}
192	}
193
194	pass3(ip)
195	register struct dinode *ip;
196	{
197	struct direct dbuf[NDIR];
198	long doff;
199	struct direct *dp;
200	register i, j;
201	int k;
202	daddr_t d;
203	ino_t kno;
204
205	if((ip->di_mode&IFMT) != IFDIR)
206	return;
207	l3tol(iaddr, ip->di_addr, NADDR);
208	doff = 0;
209	for(i=0;; i++) {
210	if(doff >= ip->di_size)
211	break;
212	d = bmap(i);
213	if(d == 0)
214	break;
215	bread(d, (char *)dbuf, sizeof(dbuf));
216	for(j=0; j<NDIR; j++) {
217	if(doff >= ip->di_size)
218	break;
219	doff += sizeof(struct direct);
220	dp = dbuf+j;
221	kno = dp->d_ino;
222	if(kno == 0)
223	continue;
224	if(aflg==0 && dotname(dp))
225	continue;
226	if(ilist[0] == 0)
227	goto pr;
228	for(k=0; ilist[k] != 0; k++)
229	if(ilist[k] == kno)
230	goto pr;
231	continue;
232	pr:
233	printf("%u ", kno);
234	pname(ino, 0);
235	printf("/%.14s", dp->d_name);
236	if (lookup(kno, 0))
237	printf("/.");
238	printf("\n");
239	}
240	}
241	}
242
243	dotname(dp)
244	register struct direct *dp;
245	{
246
247	if (dp->d_name[0]=='.')
248	if (dp->d_name[1]==0 \|\| (dp->d_name[1]=='.' && dp->d_name[2]==0))
249	return(1);
250	return(0);
251	}
252
253	pname(i, lev)
254	ino_t i;
255	{
256	register struct htab *hp;
257
258	if (i==ROOTINO)
259	return;
260	if ((hp = lookup(i, 0)) == 0) {
261	printf("???");
262	return;
263	}
264	if (lev > 10) {
265	printf("...");
266	return;
267	}
268	pname(hp->h_pino, ++lev);
269	printf("/%.14s", hp->h_name);
270	}
271
272	struct htab *
273	lookup(i, ef)
274	ino_t i;
275	{
276	register struct htab *hp;
277
278	for (hp = &htab[i%HSIZE]; hp->h_ino;) {
279	if (hp->h_ino==i)
280	return(hp);
281	if (++hp >= &htab[HSIZE])
282	hp = htab;
283	}
284	if (ef==0)
285	return(0);
286	if (++nhent >= HSIZE) {
287	fprintf(stderr, "ncheck: out of core-- increase HSIZE\n");
288	exit(1);
289	}
290	hp->h_ino = i;
291	return(hp);
292	}
293
294	bread(bno, buf, cnt)
295	daddr_t bno;
296	char *buf;
297	{
298	register i;
299
300	lseek(fi, bno*BSIZE, 0);
301	if (read(fi, buf, cnt) != cnt) {
302	fprintf(stderr, "ncheck: read error %d\n", bno);
303	for(i=0; i<BSIZE; i++)
304	buf[i] = 0;
305	}
306	}
307
308	daddr_t
309	bmap(i)
310	{
311	daddr_t ibuf[NINDIR];
312
313	if(i < NADDR-3)
314	return(iaddr[i]);
315	i -= NADDR-3;
316	if(i > NINDIR) {
317	fprintf(stderr, "ncheck: %u - huge directory\n", ino);
318	return((daddr_t)0);
319	}
320	bread(iaddr[NADDR-3], (char *)ibuf, sizeof(ibuf));
321	return(ibuf[i]);
322	}