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