1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * University Copyright- Copyright (c) 1982, 1986, 1988
31 * The Regents of the University of California
32 * All Rights Reserved
33 *
34 * University Acknowledgment- Portions of this document are derived from
35 * software developed by the University of California, Berkeley, and its
36 * contributors.
37 */
38
39 #pragma ident "%Z%%M% %I% %E% SMI"
40
41 /*
42 * ncheck -- obtain file names from reading filesystem
43 */
44
45 #define MAXNINDIR (MAXBSIZE / sizeof (daddr_t))
46
47 #include <sys/param.h>
48 #include <sys/types.h>
49 #include <sys/vnode.h>
50 #include <sys/fs/ufs_inode.h>
51 #include <sys/fs/ufs_fs.h>
52 #include <sys/fs/ufs_fsdir.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <errno.h>
57 #include <fcntl.h>
58 #include <unistd.h>
59 #include "roll_log.h"
60
61 union {
62 struct fs sblk;
63 char xxx[SBSIZE]; /* because fs is variable length */
64 } real_fs;
65 #define sblock real_fs.sblk
66
67 struct dinode *itab;
68 unsigned itab_size;
69
70
71 struct dinode *gip;
72
73 /* inode list */
74 struct ilist {
75 ino_t ino;
76 ushort_t mode;
77 uid_t uid;
78 gid_t gid;
79 } *ilist;
80 int ilist_size = 0; /* size of ilist[] */
81 int ilist_index = 0; /* current index for storing into ilist; */
82 #define ILIST_SZ_INCR 1000 /* initial size, amount to incr sz of ilist */
83 #define MAX_ILIST_INDEX() (ilist_size - 1)
84
85 struct htab
86 {
87 ino_t h_ino;
88 ino_t h_pino;
89 int h_name_index; /* index into string table */
90 } *htab;
91 unsigned htab_size; /* how much malloc'd for htab */
92
93 /*
94 * string table: used to hold filenames.
95 */
96 char *strngtab;
97 int strngloc;
98 int strngtab_size;
99 #define STRNGTAB_INCR (1024*16) /* amount to grow strngtab */
100 #define MAX_STRNGTAB_INDEX() (strngtab_size - 1)
101 #define AVG_PATH_LEN 30 /* average (?) length of name */
102
103 long hsize;
104
105 struct dirstuff {
106 int loc;
107 struct dinode *ip;
108 char dbuf[MAXBSIZE];
109 };
110
111
112 int aflg = 0;
113 int sflg = 0;
114 int iflg = 0; /* number of inodes being searched for */
115 int mflg = 0;
116 int fi;
117 ino_t ino;
118 int nhent;
119
120 int nerror;
121
122 long atol();
123 daddr_t bmap(daddr_t);
124 void bread(diskaddr_t bno, char *buf, int cnt);
125 void check(char *file);
126 int dotname(struct direct *dp);
127 offset_t llseek();
128 struct htab *lookup(ino_t i, int ef);
129 void pass1(struct dinode *ip);
130 void pass2(struct dinode *ip);
131 void pass3(struct dinode *ip);
132 void pname(ino_t i, int lev);
133 char *strcpy();
134 void usage();
135 struct direct *dreaddir();
136 void extend_ilist();
137 int extend_strngtab(unsigned int size);
138 uchar_t *extend_tbl(uchar_t *tbl, unsigned int *current_size,
139 unsigned int new_size);
140
141 extern int optind;
142 extern char *optarg;
143
144 char *subopts [] = {
145 #define M_FLAG 0
146 "m",
147 NULL
148 };
149
150 int
main(int argc,char * argv[])151 main(int argc, char *argv[])
152 {
153 long n;
154 int opt;
155 char *suboptions, *value;
156 int suboption;
157 char *p;
158 int first = 0;
159
160 extend_ilist();
161 while ((opt = getopt(argc, argv, "ao:i:s")) != EOF) {
162 switch (opt) {
163
164 case 'a':
165 aflg++;
166 break;
167
168 case 'o':
169 /*
170 * ufs specific options.
171 */
172 suboptions = optarg;
173 while (*suboptions != '\0') {
174 suboption = getsubopt(&suboptions,
175 subopts, &value);
176 switch (suboption) {
177
178 case M_FLAG:
179 mflg++;
180 break;
181
182 default:
183 usage();
184 }
185 }
186 break;
187
188 case 'i':
189 while ((p = (char *)strtok((first++ == 0 ? optarg : 0),
190 ", ")) != NULL) {
191 if ((n = atoi(p)) == 0)
192 break;
193 ilist[iflg].ino = n;
194 iflg++;
195 ilist_index = iflg;
196 if (iflg > MAX_ILIST_INDEX())
197 extend_ilist();
198 }
199 break;
200
201 case 's':
202 sflg++;
203 break;
204 #if 0
205 case 'V':
206 {
207 int opt_count;
208 char *opt_text;
209
210 (void) fprintf(stdout, "ncheck -F ufs ");
211 for (opt_count = 1; opt_count < argc;
212 opt_count++) {
213 opt_text = argv[opt_count];
214 if (opt_text)
215 (void) fprintf(stdout, " %s ",
216 opt_text);
217 }
218 (void) fprintf(stdout, "\n");
219 }
220 break;
221 #endif
222 case '?':
223 usage();
224 }
225 }
226 argc -= optind;
227 argv = &argv[optind];
228 while (argc--) {
229 check(*argv);
230 argv++;
231 }
232 return (nerror);
233 }
234
235 void
check(char * file)236 check(char *file)
237 {
238 int i, j, c;
239
240 fi = open64(file, 0);
241 if (fi < 0) {
242 (void) fprintf(stderr, "ncheck: cannot open %s\n", file);
243 nerror++;
244 return;
245 }
246 nhent = 0;
247 (void) printf("%s:\n", file);
248 sync();
249 bread((diskaddr_t)SBLOCK, (char *)&sblock, SBSIZE);
250 if ((sblock.fs_magic != FS_MAGIC) &&
251 (sblock.fs_magic != MTB_UFS_MAGIC)) {
252 (void) printf("%s: not a ufs file system\n", file);
253 nerror++;
254 return;
255 }
256
257 if ((sblock.fs_magic == FS_MAGIC) &&
258 ((sblock.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2) &&
259 (sblock.fs_version != UFS_VERSION_MIN))) {
260 (void) printf("%s: unrecognized ufs version number %d\n",
261 file, sblock.fs_version);
262 nerror++;
263 return;
264 }
265
266 if ((sblock.fs_magic == MTB_UFS_MAGIC) &&
267 ((sblock.fs_version > MTB_UFS_VERSION_1) ||
268 (sblock.fs_version < MTB_UFS_VERSION_MIN))) {
269 (void) printf("%s: unrecognized ufs version number %d\n",
270 file, sblock.fs_version);
271 nerror++;
272 return;
273 }
274
275 /* If fs is logged, roll the log. */
276 if (sblock.fs_logbno) {
277 switch (rl_roll_log(file)) {
278 case RL_SUCCESS:
279 /*
280 * Reread the superblock. Rolling the log may have
281 * changed it.
282 */
283 bread((diskaddr_t)SBLOCK, (char *)&sblock, SBSIZE);
284 break;
285 case RL_SYSERR:
286 (void) printf("Warning: cannot roll log for %s. %s\n",
287 file, strerror(errno));
288 break;
289 default:
290 (void) printf("Warning: cannot roll log for %s.\n",
291 file);
292 break;
293 }
294 }
295
296 itab = (struct dinode *)extend_tbl((uchar_t *)itab, &itab_size,
297 (unsigned)(sblock.fs_ipg * sizeof (struct dinode)));
298 if (itab == 0) {
299 (void) fprintf(stderr,
300 "ncheck: not enough memory for itab table\n");
301 nerror++;
302 return;
303 }
304
305 hsize = sblock.fs_ipg * sblock.fs_ncg - sblock.fs_cstotal.cs_nifree + 1;
306
307 htab = (struct htab *)extend_tbl((uchar_t *)htab, &htab_size,
308 (unsigned)(hsize * sizeof (struct htab)));
309 if (htab == 0) {
310 (void) fprintf(stderr,
311 "ncheck: not enough memory for htab table\n");
312 nerror++;
313 return;
314 }
315
316 if (!extend_strngtab(AVG_PATH_LEN * hsize)) {
317 (void) printf("not enough memory to allocate tables\n");
318 nerror++;
319 return;
320 }
321 strngloc = 0;
322
323 ino = 0;
324 for (c = 0; c < sblock.fs_ncg; c++) {
325 bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
326 (int)(sblock.fs_ipg * sizeof (struct dinode)));
327 for (j = 0; j < sblock.fs_ipg; j++) {
328 if (itab[j].di_smode != 0) {
329 itab[j].di_mode = itab[j].di_smode;
330 if (itab[j].di_suid != UID_LONG)
331 itab[j].di_uid = itab[j].di_suid;
332 if (itab[j].di_sgid != GID_LONG)
333 itab[j].di_gid = itab[j].di_sgid;
334 pass1(&itab[j]);
335 }
336 ino++;
337 }
338 }
339 ilist[ilist_index++].ino = 0;
340 if (ilist_index > MAX_ILIST_INDEX())
341 extend_ilist();
342 ino = 0;
343 for (c = 0; c < sblock.fs_ncg; c++) {
344 bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
345 (int)(sblock.fs_ipg * sizeof (struct dinode)));
346 for (j = 0; j < sblock.fs_ipg; j++) {
347
348 if (itab[j].di_smode != 0) {
349 itab[j].di_mode = itab[j].di_smode;
350 pass2(&itab[j]);
351 }
352 ino++;
353 }
354 }
355 ino = 0;
356 for (c = 0; c < sblock.fs_ncg; c++) {
357 bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
358 (int)(sblock.fs_ipg * sizeof (struct dinode)));
359 for (j = 0; j < sblock.fs_ipg; j++) {
360 if (itab[j].di_smode != 0) {
361 itab[j].di_mode = itab[j].di_smode;
362 pass3(&itab[j]);
363 }
364 ino++;
365 }
366 }
367 (void) close(fi);
368
369 /*
370 * Clear those elements after inodes specified by "-i" out of
371 * ilist.
372 */
373 for (i = iflg; i < ilist_index; i++) {
374 ilist[i].ino = 0;
375 }
376 ilist_index = iflg;
377 }
378
379 void
pass1(struct dinode * ip)380 pass1(struct dinode *ip)
381 {
382 int i;
383
384 if (mflg) {
385 for (i = 0; i < iflg; i++)
386 if (ino == ilist[i].ino) {
387 ilist[i].mode = ip->di_mode;
388 ilist[i].uid = ip->di_uid;
389 ilist[i].gid = ip->di_gid;
390 }
391 }
392 if ((ip->di_mode & IFMT) != IFDIR) {
393 if (sflg == 0)
394 return;
395 if ((ip->di_mode & IFMT) == IFBLK ||
396 (ip->di_mode & IFMT) == IFCHR ||
397 ip->di_mode&(ISUID|ISGID)) {
398 ilist[ilist_index].ino = ino;
399 ilist[ilist_index].mode = ip->di_mode;
400 ilist[ilist_index].uid = ip->di_uid;
401 ilist[ilist_index].gid = ip->di_gid;
402 if (++ilist_index > MAX_ILIST_INDEX())
403 extend_ilist();
404 return;
405 }
406 }
407 (void) lookup(ino, 1);
408 }
409
410 void
pass2(struct dinode * ip)411 pass2(struct dinode *ip)
412 {
413 struct direct *dp;
414 struct dirstuff dirp;
415 struct htab *hp;
416
417
418 if ((ip->di_mode&IFMT) != IFDIR)
419 return;
420 dirp.loc = 0;
421 dirp.ip = ip;
422 gip = ip;
423 for (dp = dreaddir(&dirp); dp != NULL; dp = dreaddir(&dirp)) {
424 int nmlen;
425
426 if (dp->d_ino == 0)
427 continue;
428
429 hp = lookup(dp->d_ino, 0);
430 if (hp == 0)
431 continue;
432
433 if (dotname(dp))
434 continue;
435 hp->h_pino = ino;
436 nmlen = strlen(dp->d_name);
437
438 if (strngloc + nmlen + 1 > MAX_STRNGTAB_INDEX()) {
439 if (!extend_strngtab(STRNGTAB_INCR)) {
440 perror("ncheck: can't grow string table\n");
441 exit(32);
442 }
443 }
444
445 hp->h_name_index = strngloc;
446 (void) strcpy(&strngtab[strngloc], dp->d_name);
447 strngloc += nmlen + 1;
448 }
449 }
450
451 void
pass3(struct dinode * ip)452 pass3(struct dinode *ip)
453 {
454 struct direct *dp;
455 struct dirstuff dirp;
456 int k;
457
458 if ((ip->di_mode&IFMT) != IFDIR)
459 return;
460 dirp.loc = 0;
461 dirp.ip = ip;
462 gip = ip;
463 for (dp = dreaddir(&dirp); dp != NULL; dp = dreaddir(&dirp)) {
464 if (aflg == 0 && dotname(dp))
465 continue;
466
467 if (sflg == 0 && iflg == 0)
468 goto pr;
469 for (k = 0; k < ilist_index && ilist[k].ino != 0; k++) {
470 if (ilist[k].ino == dp->d_ino) {
471 break;
472 }
473 }
474 if (ilist[k].ino == 0)
475 continue;
476 if (mflg)
477 (void) printf("mode %-6o uid %-5ld gid %-5ld ino ",
478 ilist[k].mode, ilist[k].uid, ilist[k].gid);
479 pr:
480 (void) printf("%-5u\t", dp->d_ino);
481 pname(ino, 0);
482 (void) printf("/%s", dp->d_name);
483 if (lookup(dp->d_ino, 0))
484 (void) printf("/.");
485 (void) printf("\n");
486 }
487 }
488
489 /*
490 * get next entry in a directory.
491 */
492 struct direct *
dreaddir(struct dirstuff * dirp)493 dreaddir(struct dirstuff *dirp)
494 {
495 struct direct *dp;
496 daddr_t lbn, d;
497
498 for (;;) {
499
500 if (dirp->loc >= (int)dirp->ip->di_size)
501 return (NULL);
502 if (blkoff(&sblock, dirp->loc) == 0) {
503
504 lbn = lblkno(&sblock, dirp->loc);
505
506 d = bmap(lbn);
507 if (d == 0)
508 return (NULL);
509
510 bread(fsbtodb(&sblock, d), dirp->dbuf,
511 (int)dblksize(&sblock, dirp->ip, (int)lbn));
512
513 }
514 dp = (struct direct *)
515 (dirp->dbuf + blkoff(&sblock, dirp->loc));
516 dirp->loc += dp->d_reclen;
517 if (dp->d_ino == 0) {
518 continue;
519 }
520 return (dp);
521 }
522 }
523
524 int
dotname(struct direct * dp)525 dotname(struct direct *dp)
526 {
527
528 if (dp->d_name[0] == '.') {
529 if (dp->d_name[1] == 0 ||
530 (dp->d_name[1] == '.' && dp->d_name[2] == 0))
531 return (1);
532 }
533 return (0);
534 }
535
536 void
pname(ino_t i,int lev)537 pname(ino_t i, int lev)
538 {
539 struct htab *hp;
540
541 if (i == UFSROOTINO)
542 return;
543
544 if ((hp = lookup(i, 0)) == 0) {
545 (void) printf("???");
546 return;
547 }
548 if (lev > 10) {
549 (void) printf("...");
550 return;
551 }
552 pname(hp->h_pino, ++lev);
553 (void) printf("/%s", &(strngtab[hp->h_name_index]));
554
555 }
556
557 struct htab *
lookup(ino_t i,int ef)558 lookup(ino_t i, int ef)
559 {
560 struct htab *hp;
561
562 for (hp = &htab[(int)i%hsize]; hp->h_ino; ) {
563 if (hp->h_ino == i)
564 return (hp);
565 if (++hp >= &htab[hsize])
566 hp = htab;
567 }
568
569 if (ef == 0)
570 return (0);
571 if (++nhent >= hsize) {
572 (void) fprintf(stderr, "ncheck: hsize of %ld is too small\n",
573 hsize);
574 exit(32);
575 }
576 hp->h_ino = i;
577 return (hp);
578 }
579
580 void
bread(diskaddr_t bno,char * buf,int cnt)581 bread(diskaddr_t bno, char *buf, int cnt)
582 {
583 int i;
584 int got;
585
586 if (llseek(fi, (offset_t)bno * DEV_BSIZE, 0) == -1) {
587 (void) fprintf(stderr, "ncheck: lseek error %lld\n",
588 (offset_t)bno * DEV_BSIZE);
589
590 for (i = 0; i < cnt; i++) {
591 buf[i] = 0;
592 }
593
594 return;
595 }
596
597 got = read((int)fi, buf, cnt);
598
599 if (got != cnt) {
600 (void) fprintf(stderr,
601 "ncheck: read error at block %lld (wanted %d got %d)\n",
602 bno, cnt, got);
603
604 for (i = 0; i < cnt; i++)
605 buf[i] = 0;
606 }
607 }
608
609 daddr_t
bmap(daddr_t i)610 bmap(daddr_t i)
611 {
612 daddr_t ibuf[MAXNINDIR];
613
614 if (i < NDADDR)
615 return (gip->di_db[i]);
616 i -= NDADDR;
617 if (i > NINDIR(&sblock)) {
618 (void) fprintf(stderr, "ncheck: %lu - huge directory\n", ino);
619 return ((daddr_t)0);
620 }
621
622 bread(fsbtodb(&sblock, gip->di_ib[0]), (char *)ibuf, sizeof (ibuf));
623
624 return (ibuf[i]);
625 }
626
627 void
usage()628 usage()
629 {
630 (void) fprintf(stderr,
631 /*CSTYLED*/
632 "ufs usage: ncheck [-F ufs] [generic options] [-a -i #list -s] [-o m] special\n");
633 exit(32);
634 }
635
636
637 /*
638 * Extend or create the inode list;
639 * this is used to contains the list of inodes we've been
640 * asked to check using the "-i" flag and to hold the
641 * inode numbers of files which we detect as being
642 * blk|char|setuid|setgid ("-s" flag support).
643 * Preserves contents.
644 */
645 void
extend_ilist()646 extend_ilist()
647 {
648 ilist_size += ILIST_SZ_INCR;
649 ilist = (struct ilist *)realloc(ilist,
650 (ilist_size * sizeof (struct ilist)));
651
652 if (ilist == NULL) {
653 perror("ncheck: not enough memory to grow ilist\n");
654 exit(32);
655 }
656 }
657
658 /*
659 * Extend or create the string table.
660 * Preserves contents.
661 * Return non-zero for success.
662 */
663 int
extend_strngtab(unsigned int size)664 extend_strngtab(unsigned int size)
665 {
666 strngtab_size += size;
667 strngtab = (char *)realloc(strngtab, strngtab_size);
668
669 return ((int)strngtab);
670 }
671
672 /*
673 * Extend or create a table, throwing away previous
674 * contents.
675 * Return null on failure.
676 */
677 uchar_t *
extend_tbl(uchar_t * tbl,unsigned int * current_size,unsigned int new_size)678 extend_tbl(uchar_t *tbl, unsigned int *current_size, unsigned int new_size)
679 {
680 /*
681 * if we've already allocated tbl,
682 * but it is too small, free it.
683 * we don't realloc because we are throwing
684 * away its contents.
685 */
686
687 if (tbl && (*current_size < new_size)) {
688 free(tbl);
689 tbl = NULL;
690 }
691
692 if (tbl == NULL) {
693 tbl = (uchar_t *)malloc(new_size);
694 if (tbl == 0)
695 return ((uchar_t *)0);
696
697 *current_size = new_size;
698 }
699 (void) memset(tbl, 0, new_size);
700
701 return (tbl);
702 }
703