xref: /titanic_50/usr/src/cmd/fs.d/ufs/ff/ff.c (revision c1c6f601cc48d067049ea58a07349897a8e225f2)
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) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 /*
30  * Portions of this source code were derived from Berkeley 4.3 BSD
31  * under license from the Regents of the University of California.
32  */
33 
34 #pragma ident	"%Z%%M%	%I%	%E% SMI"
35 
36 /*
37  * ff -- obtain file names from reading filesystem
38  */
39 
40 #define	NB		500
41 #define	MAXNINDIR	(MAXBSIZE / sizeof (daddr32_t))
42 
43 #include <sys/param.h>
44 #include <sys/types.h>
45 #include <sys/mntent.h>
46 #include <sys/vnode.h>
47 #include <sys/fs/ufs_inode.h>
48 #include <sys/stat.h>
49 #include <sys/fs/ufs_fs.h>
50 #include <sys/fs/ufs_fsdir.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <strings.h>
54 #include <errno.h>
55 #include <fcntl.h>
56 #include <unistd.h>
57 #include <pwd.h>
58 #include "roll_log.h"
59 
60 #define	MIN_PHYS_READ	BBSIZE
61 #define	DAY		(24*60*60)
62 
63 
64 union {
65 	struct	fs	sblk;
66 	char xxx[SBSIZE];	/* because fs is variable length */
67 } real_fs;
68 #define	sblock real_fs.sblk
69 
70 struct	dinode  *itab;	/*  = (struct dinode *)itab; */
71 
72 struct 	dinode	*gip;
73 
74 struct ilist {
75 	ino_t	ino;
76 	ushort_t	mode;
77 	uid_t	uid;
78 	gid_t	gid;
79 } ilist[NB];
80 
81 struct	htab
82 {
83 	ino_t	h_ino;
84 	ino_t	h_pino;
85 	int	h_name_index;		/* index into string table */
86 } *htab;
87 char *strngtab;
88 long hsize;
89 int strngloc;
90 int strngtab_size;
91 #define	STRNGTAB_INCR	(1024*16)	/* amount to grow strngtab */
92 #define	MAX_STRNGTAB_INDEX()	(strngtab_size - 1)
93 #define	AVG_PATH_LEN	30		/* average (?) length of name */
94 
95 struct dirstuff {
96 	int loc;
97 	struct dinode *ip;
98 	char dbuf[MAXBSIZE];
99 };
100 int	Aflg = 0;	/* accessed in n days */
101 int	Mflg = 0;	/* modified in n days */
102 int	Nflg = 0;	/* modified more recently than 'file' */
103 int	Cflg = 0;	/* changed within n days */
104 int	aflg = 0;	/* print the names `.'  and  `..' */
105 int	sflg = 0; /* print only special files and files with set-user-ID mode */
106 int	Sflg = 0;	/* print file size */
107 int	iflg = 0;	/* number of inodes being searched for */
108 int	Iflg = 0;	/* do not print i-number */
109 int	Lflg = 0;	/* supplementary list of multiply linked files */
110 int	mflg = 0;
111 int	pflg = 0;	/* a prefix exists */
112 int	uflg = 0;	/* print the owner's login name */
113 int	fi;
114 ino_t	ino;
115 int	nhent;
116 int	nxfile;
117 int	imax;		/* highest inode number */
118 int	inode_reads;
119 int	passwd_lookups;
120 int	Adelay;		/* Access delay */
121 int	Asign;		/* Access sign */
122 int	Mdelay;		/* Modify delay */
123 int	Msign;		/* Modify sign */
124 int	Cdelay;		/* change delay */
125 int	Csign;		/* change sign */
126 time_t	Nage;		/* Last modification time of the file */
127 char	*Lname;		/* filename for supplementary list */
128 FILE	*Lfile;		/* file for supplementary list */
129 
130 /*
131  * Function prototypes
132  */
133 void check(char *file);
134 void pass1(struct dinode *ip);
135 void pass2(struct dinode *ip);
136 void pass3(struct dinode *ip);
137 struct direct *dreaddir(struct dirstuff *dirp);
138 int dotname(struct direct *dp);
139 void pname(FILE *stream, ino_t i, int lev);
140 struct htab *lookup(ino_t i, int ef);
141 void bread(diskaddr_t bno, char *buf, int cnt);
142 diskaddr_t bmap(diskaddr_t i);
143 struct dinode *ginode(ino_t inumber);
144 char *user_name(int uid);
145 int cmp(int a, int b, int s);
146 time_t mod_time(char *file);
147 void out_multilinks();
148 void usage();
149 int extend_strngtab(unsigned int size);
150 
151 long	atol();
152 offset_t llseek();
153 char 	*strcpy();
154 
155 char	*prefix;
156 time_t	Today;
157 int	nerror;
158 
159 
160 extern int	optind;
161 extern char	*optarg;
162 
163 char *subopts [] = {
164 #define	A_FLAG		0
165 	"a",
166 #define	M_FLAG		1
167 	"m",
168 #define	S_FLAG		2
169 	"s",
170 	NULL
171 	};
172 
173 int
174 main(int argc, char *argv[])
175 {
176 	long n;
177 	int	opt;
178 	char	*suboptions,	*value;
179 	char *p;
180 	int first = 0;
181 
182 	Today = time((time_t *)0);
183 	while ((opt = getopt(argc, argv, "Ia:c:i:lm:n:o:p:su")) != EOF) {
184 		switch (opt) {
185 
186 		case 'a':
187 			Aflg++;
188 			Adelay = atoi(optarg);
189 			Asign = optarg[0];
190 			break;
191 
192 		case 'I':
193 			Iflg++;
194 			break;
195 
196 		case 'c':
197 			Cflg++;
198 			Cdelay = atoi(optarg);
199 			Csign = optarg[0];
200 			break;
201 
202 		case 'l':
203 			Lflg++;
204 			Lname = tmpnam((char *)0);
205 			if ((Lfile = fopen(Lname, "w+")) == NULL) {
206 				perror("open");
207 				(void) fprintf(stderr,
208 				"ff: unable to open temp file, -l ignored\n");
209 				Lflg = 0;
210 			}
211 			break;
212 
213 		case 'm':
214 			Mflg++;
215 			Mdelay = atoi(optarg);
216 			Msign = optarg[0];
217 			break;
218 
219 		case 'n':
220 			Nflg++;
221 			Nage = mod_time(optarg);
222 			break;
223 
224 		case 'o':
225 			/*
226 			 * ufs specific options.
227 			 */
228 			suboptions = optarg;
229 
230 			if (*suboptions == '\0')
231 				usage();
232 			while (*suboptions != '\0') {
233 				switch ((getsubopt(&suboptions,
234 							subopts, &value))) {
235 
236 				case A_FLAG:
237 					aflg++;
238 					break;
239 
240 				case M_FLAG:
241 					mflg++;
242 					break;
243 
244 				case S_FLAG:
245 					sflg++;
246 					break;
247 
248 				default:
249 					usage();
250 				}
251 			}
252 			break;
253 
254 		case 'i':
255 			while ((p = (char *)strtok(((first++ == 0) ?
256 			optarg: ((char *)0)), ", ")) != NULL) {
257 				if ((n = atoi(p)) == 0)
258 					break;
259 				ilist[iflg].ino = n;
260 				nxfile = iflg;
261 				iflg++;
262 			}
263 			break;
264 
265 		case 'p':
266 			prefix = optarg;
267 			pflg++;
268 			break;
269 
270 		case 's':
271 			Sflg++;
272 			break;
273 
274 		case 'u':
275 			uflg++;
276 			break;
277 
278 		case '?':
279 			usage();
280 		}
281 	}
282 	argc -= optind;
283 	argv = &argv[optind];
284 	while (argc--) {
285 		check(*argv);
286 		argv++;
287 	}
288 	if (Lflg) {
289 		out_multilinks();
290 	}
291 	if (nerror)
292 		return (32);
293 	return (0);
294 }
295 
296 void
297 check(char *file)
298 {
299 	int i, j, c;
300 
301 	fi = open64(file, 0);
302 	if (fi < 0) {
303 		(void) fprintf(stderr, "ff: cannot open %s\n", file);
304 		nerror++;
305 		return;
306 	}
307 	nhent = 0;
308 	(void) printf("%s:\n", file);
309 	sync();
310 	bread(SBLOCK, (char *)&sblock, SBSIZE);
311 	if ((sblock.fs_magic != FS_MAGIC) &&
312 	    (sblock.fs_magic != MTB_UFS_MAGIC)) {
313 		(void) fprintf(stderr, "%s: not a ufs file system\n", file);
314 		nerror++;
315 		return;
316 	}
317 
318 	if (sblock.fs_magic == FS_MAGIC &&
319 	    (sblock.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
320 	    sblock.fs_version != UFS_VERSION_MIN)) {
321 		(void) fprintf(stderr, "%s: unrecognized version of UFS: %d\n",
322 		    file, sblock.fs_version);
323 		nerror++;
324 		return;
325 	}
326 
327 	if (sblock.fs_magic == MTB_UFS_MAGIC &&
328 	    (sblock.fs_version > MTB_UFS_VERSION_1 ||
329 	    sblock.fs_version < MTB_UFS_VERSION_MIN)) {
330 		(void) fprintf(stderr, "%s: unrecognized version of UFS: %d\n",
331 		    file, sblock.fs_version);
332 		nerror++;
333 		return;
334 	}
335 
336 	/* If fs is logged, roll the log. */
337 	if (sblock.fs_logbno) {
338 		switch (rl_roll_log(file)) {
339 		case RL_SUCCESS:
340 			/*
341 			 * Reread the superblock.  Rolling the log may have
342 			 * changed it.
343 			 */
344 			bread(SBLOCK, (char *)&sblock, SBSIZE);
345 			break;
346 		case RL_SYSERR:
347 			(void) printf("Warning: Cannot roll log for %s.  %s\n",
348 				file, strerror(errno));
349 			break;
350 		default:
351 			(void) printf("Warning: Cannot roll log for %s.\n ",
352 				file);
353 			break;
354 		}
355 	}
356 
357 
358 	itab = (struct dinode *)calloc(sblock.fs_ipg, sizeof (struct dinode));
359 	imax = sblock.fs_ncg * sblock.fs_ipg;
360 
361 	hsize = sblock.fs_ipg * sblock.fs_ncg - sblock.fs_cstotal.cs_nifree + 1;
362 	htab = (struct htab *)calloc(hsize, sizeof (struct htab));
363 
364 	if (!extend_strngtab(AVG_PATH_LEN * hsize)) {
365 		(void) printf("not enough memory to allocate tables\n");
366 		nerror++;
367 		return;
368 	}
369 	strngloc = 0;
370 
371 	if ((itab == NULL) || (htab == NULL)) {
372 		(void) printf("not enough memory to allocate tables\n");
373 		nerror++;
374 		return;
375 	}
376 	ino = 0;
377 	for (c = 0; c < sblock.fs_ncg; c++) {
378 		bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
379 		    (int)(sblock.fs_ipg * sizeof (struct dinode)));
380 		for (j = 0; j < sblock.fs_ipg; j++) {
381 			if (itab[j].di_smode != 0) {
382 				itab[j].di_mode = itab[j].di_smode;
383 				if (itab[j].di_suid != (o_uid_t)UID_LONG)
384 				itab[j].di_uid = (unsigned int)itab[j].di_suid;
385 				if (itab[j].di_sgid != GID_LONG)
386 				itab[j].di_gid = (unsigned int)itab[j].di_sgid;
387 				pass1(&itab[j]);
388 			}
389 			ino++;
390 		}
391 	}
392 	ilist[nxfile+1].ino = 0;
393 	ino = 0;
394 	for (c = 0; c < sblock.fs_ncg; c++) {
395 		bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
396 		    (int)(sblock.fs_ipg * sizeof (struct dinode)));
397 		for (j = 0; j < sblock.fs_ipg; j++) {
398 			if (itab[j].di_smode != 0) {
399 				itab[j].di_mode = itab[j].di_smode;
400 				pass2(&itab[j]);
401 			}
402 			ino++;
403 		}
404 	}
405 	ino = 0;
406 	for (c = 0; c < sblock.fs_ncg; c++) {
407 		bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
408 		    (int)(sblock.fs_ipg * sizeof (struct dinode)));
409 		for (j = 0; j < sblock.fs_ipg; j++) {
410 			if (itab[j].di_smode != 0) {
411 				itab[j].di_mode = itab[j].di_smode;
412 				pass3(&itab[j]);
413 			}
414 			ino++;
415 		}
416 	}
417 	(void) close(fi);
418 	for (i = iflg; i < NB; i++)
419 		ilist[i].ino = 0;
420 	nxfile = iflg;
421 	free(itab);
422 	free(htab);
423 	free(strngtab);
424 }
425 
426 void
427 pass1(struct dinode *ip)
428 {
429 	int i;
430 
431 	if (mflg)
432 		for (i = 0; i < iflg; i++)
433 			if (ino == ilist[i].ino) {
434 				ilist[i].mode = ip->di_mode;
435 				ilist[i].uid = ip->di_uid;
436 				ilist[i].gid = ip->di_gid;
437 			}
438 	if ((ip->di_mode & IFMT) != IFDIR) {
439 		if (sflg == 0 || nxfile >= NB)
440 			return;
441 		if ((ip->di_mode&IFMT) == IFBLK ||
442 		    (ip->di_mode&IFMT) == IFCHR || ip->di_mode&(ISUID|ISGID)) {
443 			ilist[nxfile].ino = ino;
444 			ilist[nxfile].mode = ip->di_mode;
445 			ilist[nxfile].uid = ip->di_uid;
446 			ilist[nxfile++].gid = ip->di_gid;
447 			return;
448 		}
449 	}
450 	(void) lookup(ino, 1);
451 }
452 
453 void
454 pass2(struct dinode *ip)
455 {
456 	struct direct *dp;
457 	struct dirstuff dirp;
458 	struct htab *hp;
459 
460 	if ((ip->di_mode&IFMT) != IFDIR)
461 		return;
462 	dirp.loc = 0;
463 	dirp.ip = ip;
464 	gip = ip;
465 	for (dp = dreaddir(&dirp); dp != NULL; dp = dreaddir(&dirp)) {
466 		int nmlen;
467 
468 		if (dp->d_ino == 0)
469 			continue;
470 		hp = lookup(dp->d_ino, 0);
471 		if (hp == 0)
472 			continue;
473 		if (dotname(dp))
474 			continue;
475 		hp->h_pino = ino;
476 		nmlen = strlen(dp->d_name);
477 
478 		if (strngloc + nmlen + 1 > MAX_STRNGTAB_INDEX()) {
479 			if (!extend_strngtab(STRNGTAB_INCR)) {
480 				perror("ncheck: can't grow string table\n");
481 				exit(32);
482 			}
483 		}
484 
485 		hp->h_name_index = strngloc;
486 		(void) strcpy(&strngtab[strngloc], dp->d_name);
487 		strngloc += nmlen + 1;
488 	}
489 }
490 
491 void
492 pass3(struct dinode *ip)
493 {
494 	struct direct *dp;
495 	struct dirstuff dirp;
496 	struct dinode   *dip;
497 	int k;
498 
499 	if ((ip->di_mode&IFMT) != IFDIR)
500 		return;
501 	dirp.loc = 0;
502 	dirp.ip = ip;
503 	gip = ip;
504 	for (dp = dreaddir(&dirp); dp != NULL; dp = dreaddir(&dirp)) {
505 		if (aflg == 0 && dotname(dp))
506 			continue;
507 		if (sflg == 0 && iflg == 0)
508 			goto pr;
509 		for (k = 0; ilist[k].ino != 0; k++)
510 			if (ilist[k].ino == dp->d_ino)
511 				break;
512 		if (ilist[k].ino == 0)
513 			continue;
514 		if (mflg)
515 			(void) printf("mode %-6o uid %-5ld gid %-5ld ino ",
516 			    ilist[k].mode, ilist[k].uid, ilist[k].gid);
517 	pr:
518 		if (Sflg || uflg || Aflg || Mflg || Cflg || Nflg || Lflg)
519 			dip = ginode(dp->d_ino);
520 		if ((!Aflg ||
521 		cmp((Today - dip->di_un.di_icom.ic_atime)/DAY, Adelay,
522 		    Asign)) &&
523 		    (!Mflg || cmp((Today - dip->di_un.di_icom.ic_mtime)/DAY,
524 			Mdelay, Msign)) &&
525 		    (!Cflg || cmp((Today - dip->di_un.di_icom.ic_mtime)/DAY,
526 			Cdelay, Csign)) &&
527 		    (!Nflg || cmp(dip->di_un.di_icom.ic_mtime, Nage, '+'))) {
528 			if (Iflg == 0)
529 				(void) printf("%-5u\t", dp->d_ino);
530 			pname(stdout, ino, 0);
531 			(void) printf("/%s", dp->d_name);
532 			if (lookup(dp->d_ino, 0))
533 				(void) printf("/.");
534 			if (Sflg)
535 				(void) printf("\t%6lld",
536 				    dip->di_un.di_icom.ic_lsize);
537 			if (uflg)
538 				(void) printf("\t%s",
539 				    user_name(dip->di_un.di_icom.ic_uid));
540 			(void) printf("\n");
541 			if (Lflg && (dip->di_un.di_icom.ic_nlink > 1)) {
542 				(void) fprintf(Lfile, "%-5u\t",
543 					dp->d_ino);
544 				(void) fprintf(Lfile, "%-5u\t",
545 					dip->di_un.di_icom.ic_nlink);
546 				pname(Lfile, ino, 0);
547 				(void) fprintf(Lfile, "/%s\n", dp->d_name);
548 			}
549 		}
550 	}
551 }
552 
553 
554 
555 /*
556  * get next entry in a directory.
557  */
558 struct direct *
559 dreaddir(struct dirstuff *dirp)
560 {
561 	struct direct *dp;
562 	diskaddr_t lbn, d;
563 
564 	for (;;) {
565 		if (dirp->loc >= (int)dirp->ip->di_size)
566 			return (NULL);
567 		if (blkoff(&sblock, dirp->loc) == 0) {
568 			lbn = lblkno(&sblock, dirp->loc);
569 			d = bmap(lbn);
570 			if (d == 0)
571 				return (NULL);
572 			bread(fsbtodb(&sblock, d), dirp->dbuf,
573 			    (int)dblksize(&sblock, dirp->ip, (int)lbn));
574 		}
575 		dp = (struct direct *)
576 		    (dirp->dbuf + blkoff(&sblock, dirp->loc));
577 		dirp->loc += dp->d_reclen;
578 		if (dp->d_ino == 0)
579 			continue;
580 		return (dp);
581 	}
582 }
583 
584 int
585 dotname(struct direct *dp)
586 {
587 
588 	if (dp->d_name[0] == '.')
589 		if (dp->d_name[1] == 0 ||
590 		    (dp->d_name[1] == '.' && dp->d_name[2] == 0))
591 			return (1);
592 	return (0);
593 }
594 
595 void
596 pname(FILE *stream, ino_t i, int lev)
597 {
598 	struct htab *hp;
599 
600 	if (i == UFSROOTINO)
601 		return;
602 	if ((hp = lookup(i, 0)) == 0) {
603 		(void) fprintf(stream, "???");
604 		return;
605 	}
606 	if (lev > 10) {
607 		(void) fprintf(stream, "...");
608 		return;
609 	}
610 	pname(stream, hp->h_pino, ++lev);
611 	if (pflg)
612 		(void) fprintf(stream, "%s/%s", prefix,
613 			&(strngtab[hp->h_name_index]));
614 	else
615 		(void) fprintf(stream, "/%s",
616 			&(strngtab[hp->h_name_index]));
617 }
618 
619 struct htab *
620 lookup(ino_t i, int ef)
621 {
622 	struct htab *hp;
623 
624 	for (hp = &htab[(int)i%hsize]; hp->h_ino; ) {
625 		if (hp->h_ino == i)
626 			return (hp);
627 		if (++hp >= &htab[hsize])
628 			hp = htab;
629 	}
630 	if (ef == 0)
631 		return (0);
632 	if (++nhent >= hsize) {
633 		(void) fprintf(stderr,
634 		    "ff: hsize of %ld is too small\n", hsize);
635 		exit(32);
636 	}
637 	hp->h_ino = i;
638 	return (hp);
639 }
640 
641 void
642 bread(diskaddr_t bno, char *buf, int cnt)
643 {
644 	int i;
645 	int got;
646 	offset_t offset;
647 
648 	offset = (offset_t)bno * DEV_BSIZE;
649 	if (llseek(fi, offset, 0) == (offset_t)-1) {
650 		(void) fprintf(stderr,
651 		    "ff: llseek error %lx %lx\n",
652 		    ((long *)&offset)[0], ((long *)&offset)[1]);
653 		for (i = 0; i < cnt; i++)
654 			buf[i] = 0;
655 		return;
656 	}
657 
658 	got = read((int)fi, buf, cnt);
659 	if (got != cnt) {
660 		perror("read");
661 		(void) fprintf(stderr,
662 			"ff: (wanted %d got %d blk %lld)\n", cnt, got, bno);
663 		for (i = 0; i < cnt; i++)
664 			buf[i] = 0;
665 	}
666 }
667 
668 diskaddr_t
669 bmap(diskaddr_t i)
670 {
671 	daddr32_t ibuf[MAXNINDIR];
672 
673 	if (i < NDADDR)
674 		return ((diskaddr_t)gip->di_db[i]);
675 	i -= NDADDR;
676 	if (i > NINDIR(&sblock)) {
677 		(void) fprintf(stderr, "ff    : %lu - huge directory\n", ino);
678 		return ((diskaddr_t)0);
679 	}
680 	bread(fsbtodb(&sblock, gip->di_ib[0]), (char *)ibuf, sizeof (ibuf));
681 	return ((diskaddr_t)ibuf[i]);
682 }
683 
684 struct dinode *
685 ginode(ino_t inumber)
686 {
687 	diskaddr_t		iblk;
688 	diskaddr_t		dblk;
689 	int		ioff;
690 	static diskaddr_t	curr_dblk;
691 	static char	buf[MIN_PHYS_READ];
692 	struct dinode	*ibuf;
693 
694 	if (inumber < UFSROOTINO || (int)inumber > imax) {
695 		(void) fprintf(stderr,
696 		    "bad inode number %ld to ginode\n", inumber);
697 		exit(32);
698 	}
699 	iblk = itod(&sblock, (int)inumber);
700 	dblk = fsbtodb(&sblock, iblk);
701 	ioff = itoo(&sblock, (int)inumber);
702 	if (dblk != curr_dblk) {
703 		bread(dblk, &buf[0], sizeof (buf));
704 		curr_dblk = dblk;
705 		inode_reads++;
706 	}
707 	ibuf = (struct dinode *)&buf[0];
708 	ibuf += ioff;
709 	return (ibuf);
710 }
711 
712 #define	HASHNAMESIZE 16
713 
714 struct name_ent {
715 	struct name_ent	*name_nxt;
716 	int		name_uid;
717 	char		*name_string;
718 };
719 struct name_ent *hashtable[HASHNAMESIZE];
720 
721 char *
722 user_name(int uid)
723 {
724 	int		h_index;
725 	struct name_ent	*hp;
726 	struct passwd	*pwent;
727 
728 	h_index = uid % HASHNAMESIZE;
729 	for (hp = hashtable[h_index]; hp != NULL; hp = hp->name_nxt) {
730 		if (hp->name_uid == uid) {
731 			return (hp->name_string);
732 		}
733 	}
734 	hp = (struct name_ent *)calloc(1, sizeof (struct name_ent));
735 	hp->name_nxt = hashtable[h_index];
736 	hp->name_uid = uid;
737 	hashtable[h_index] = hp;
738 	if ((pwent = getpwuid(uid)) == NULL) {
739 		hp->name_string = "unknown";
740 	} else {
741 		hp->name_string = (char *)strdup(pwent->pw_name);
742 	}
743 	passwd_lookups++;
744 
745 	return (hp->name_string);
746 }
747 
748 int
749 cmp(int a, int b, int s)
750 {
751 	if (s == '+')
752 		return (a > b);
753 	if (s == '-')
754 		return (a < -(b));
755 	return (a == b);
756 }
757 
758 /*
759  * We can't do this one by reading the disk directly, since there
760  * is no guarantee that the file is even on a local disk.
761  */
762 time_t
763 mod_time(char *file)
764 {
765 	struct stat64	stat_buf;
766 
767 	if (stat64(file, &stat_buf) < 0) {
768 		(void) fprintf(stderr, "ff: can't stat '%s' - ignored\n", file);
769 		return (0);
770 	}
771 	return (stat_buf.st_mtime);
772 }
773 
774 void
775 out_multilinks()
776 {
777 	int	length;
778 
779 	if ((length = fseek(Lfile, 0L, 2)) < 0) {
780 		perror("fseek");
781 		exit(32);
782 	} else
783 		if ((length = ftell(Lfile)) > 0) {
784 			(void) fprintf(stdout,
785 			    "\nmultilink files\nIno\tLinks\tPathname\n\n");
786 			rewind(Lfile);
787 			while (length-- > 0)
788 				(void) putc(getc(Lfile), stdout);
789 		} else
790 			(void) fprintf(stdout, "No multilink files\n");
791 	(void) fclose(Lfile);
792 }
793 
794 void
795 usage()
796 {
797 	(void) fprintf(stderr,
798 	    "ufs usage: ff [-F ufs] [generic options] [-o a,m,s] special\n");
799 	exit(32);
800 }
801 
802 /*
803  * Extend or create the string table.
804  * Preserves contents.
805  * Return non-zero for success.
806  */
807 int
808 extend_strngtab(unsigned int size)
809 {
810 	strngtab_size += size;
811 	strngtab = (char *)realloc(strngtab, strngtab_size);
812 
813 	return ((int)strngtab);
814 }
815