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
main(int argc,char * argv[])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
check(char * file)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
pass1(struct dinode * ip)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
pass2(struct dinode * ip)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
pass3(struct dinode * ip)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 *
dreaddir(struct dirstuff * dirp)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
dotname(struct direct * dp)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
pname(FILE * stream,ino_t i,int lev)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 *
lookup(ino_t i,int ef)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
bread(diskaddr_t bno,char * buf,int cnt)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
bmap(diskaddr_t i)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 *
ginode(ino_t inumber)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 *
user_name(int uid)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
cmp(int a,int b,int s)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
mod_time(char * file)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
out_multilinks()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
usage()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
extend_strngtab(unsigned int size)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