1 /*
2 * Copyright (c) 1983, 1993
3 * The Regents of the University of California. All rights reserved.
4 * (c) UNIX System Laboratories, Inc.
5 * All or some portions of this file are derived from material licensed
6 * to the University of California by American Telephone and Telegraph
7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8 * the permission of UNIX System Laboratories, Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * @(#)dirs.c 8.7 (Berkeley) 5/1/95
35 * $FreeBSD: src/sbin/restore/dirs.c,v 1.14.2.5 2001/10/15 13:44:45 dd Exp $
36 */
37
38 #include <sys/param.h>
39 #include <sys/stat.h>
40 #include <sys/time.h>
41
42 #include <vfs/ufs/dinode.h>
43 #include <vfs/ufs/dir.h>
44 #include <protocols/dumprestore.h>
45
46 #include <err.h>
47 #include <errno.h>
48 #include <fcntl.h>
49 #include <paths.h>
50 #include <stdio.h>
51 #include <stdlib.h>
52 #include <string.h>
53 #include <unistd.h>
54
55 #include "restore.h"
56 #include "extern.h"
57
58 /*
59 * Symbol table of directories read from tape.
60 */
61 #define HASHSIZE 1000
62 #define INOHASH(val) (val % HASHSIZE)
63 struct inotab {
64 struct inotab *t_next;
65 ufs1_ino_t t_ino;
66 int32_t t_seekpt;
67 int32_t t_size;
68 };
69 static struct inotab *inotab[HASHSIZE];
70
71 /*
72 * Information retained about directories.
73 */
74 struct modeinfo {
75 ufs1_ino_t ino;
76 struct timeval timep[2];
77 mode_t mode;
78 uid_t uid;
79 gid_t gid;
80 int flags;
81 };
82
83 /*
84 * Definitions for library routines operating on directories.
85 */
86 #undef DIRBLKSIZ
87 #define DIRBLKSIZ 1024
88 struct rstdirdesc {
89 int dd_fd;
90 int32_t dd_loc;
91 int32_t dd_size;
92 char dd_buf[DIRBLKSIZ];
93 };
94
95 /*
96 * Global variables for this file.
97 */
98 static long seekptg;
99 static FILE *df, *mfg;
100 static RST_DIR *dirpg;
101 static char dirfile[MAXPATHLEN] = "#"; /* No file */
102 static char modefile[MAXPATHLEN] = "#"; /* No file */
103 static char dot[2] = "."; /* So it can be modified */
104
105 /*
106 * Format of old style directories.
107 */
108 #define ODIRSIZ 14
109 struct odirect {
110 u_short d_ino;
111 char d_name[ODIRSIZ];
112 };
113
114 static struct inotab *allocinotab(ufs1_ino_t, struct ufs1_dinode *, long);
115 static void dcvt(struct odirect *, struct direct *);
116 static void flushent(void);
117 static struct inotab *inotablookup(ufs1_ino_t);
118 static RST_DIR *opendirfile(const char *);
119 static void putdir(char *, size_t);
120 static void putent(struct direct *);
121 static void rst_seekdir(RST_DIR *, long, long);
122 static long rst_telldir(RST_DIR *);
123 static struct direct *searchdir(ufs1_ino_t, char *);
124
125 /*
126 * Extract directory contents, building up a directory structure
127 * on disk for extraction by name.
128 * If genmode is requested, save mode, owner, and times for all
129 * directories on the tape.
130 */
131 void
extractdirs(int genmode)132 extractdirs(int genmode)
133 {
134 int i;
135 struct ufs1_dinode *ip;
136 struct inotab *itp;
137 struct direct nulldir;
138 int fd;
139 const char *tmpdir;
140
141 vprintf(stdout, "Extract directories from tape\n");
142 if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0')
143 tmpdir = _PATH_TMP;
144 sprintf(dirfile, "%s/rstdir%ld", tmpdir, (long)dumpdate);
145 if (command != 'r' && command != 'R') {
146 strcat(dirfile, "-XXXXXX");
147 fd = mkstemp(dirfile);
148 } else
149 fd = open(dirfile, O_RDWR|O_CREAT|O_EXCL, 0666);
150 if (fd == -1 || (df = fdopen(fd, "w")) == NULL) {
151 if (fd != -1)
152 close(fd);
153 warn("%s - cannot create directory temporary\nfopen", dirfile);
154 done(1);
155 }
156 if (genmode != 0) {
157 sprintf(modefile, "%s/rstmode%ld", tmpdir, (long)dumpdate);
158 if (command != 'r' && command != 'R') {
159 strcat(modefile, "-XXXXXX");
160 fd = mkstemp(modefile);
161 } else
162 fd = open(modefile, O_RDWR|O_CREAT|O_EXCL, 0666);
163 if (fd == -1 || (mfg = fdopen(fd, "w")) == NULL) {
164 if (fd != -1)
165 close(fd);
166 warn("%s - cannot create modefile\nfopen", modefile);
167 done(1);
168 }
169 }
170 nulldir.d_ino = 0;
171 nulldir.d_type = DT_DIR;
172 nulldir.d_namlen = 1;
173 strcpy(nulldir.d_name, "/");
174 nulldir.d_reclen = DIRSIZ(0, &nulldir);
175 for (;;) {
176 curfile.name = "<directory file - name unknown>";
177 curfile.action = USING;
178 ip = curfile.dip;
179 if (ip == NULL || (ip->di_mode & IFMT) != IFDIR) {
180 fclose(df);
181 dirpg = opendirfile(dirfile);
182 if (dirpg == NULL)
183 fprintf(stderr, "opendirfile: %s\n",
184 strerror(errno));
185 if (mfg != NULL)
186 fclose(mfg);
187 i = dirlookup(dot);
188 if (i == 0)
189 panic("Root directory is not on tape\n");
190 return;
191 }
192 itp = allocinotab(curfile.ino, ip, seekptg);
193 getfile(putdir, xtrnull);
194 putent(&nulldir);
195 flushent();
196 itp->t_size = seekptg - itp->t_seekpt;
197 }
198 }
199
200 /*
201 * skip over all the directories on the tape
202 */
203 void
skipdirs(void)204 skipdirs(void)
205 {
206
207 while (curfile.dip && (curfile.dip->di_mode & IFMT) == IFDIR) {
208 skipfile();
209 }
210 }
211
212 /*
213 * Recursively find names and inumbers of all files in subtree
214 * pname and pass them off to be processed.
215 */
216 void
treescan(char * pname,ufs1_ino_t ino,long (* todo)(char *,ufs1_ino_t,int))217 treescan(char *pname, ufs1_ino_t ino, long (*todo)(char *, ufs1_ino_t, int))
218 {
219 struct inotab *itp;
220 struct direct *dp;
221 int namelen;
222 long bpt;
223 char locname[MAXPATHLEN + 1];
224
225 itp = inotablookup(ino);
226 if (itp == NULL) {
227 /*
228 * Pname is name of a simple file or an unchanged directory.
229 */
230 (*todo)(pname, ino, LEAF);
231 return;
232 }
233 /*
234 * Pname is a dumped directory name.
235 */
236 if ((*todo)(pname, ino, NODE) == FAIL)
237 return;
238 /*
239 * begin search through the directory
240 * skipping over "." and ".."
241 */
242 strncpy(locname, pname, sizeof(locname) - 1);
243 locname[sizeof(locname) - 1] = '\0';
244 strncat(locname, "/", sizeof(locname) - strlen(locname));
245 namelen = strlen(locname);
246 rst_seekdir(dirpg, itp->t_seekpt, itp->t_seekpt);
247 dp = rst_readdir(dirpg); /* "." */
248 if (dp != NULL && strcmp(dp->d_name, ".") == 0)
249 dp = rst_readdir(dirpg); /* ".." */
250 else
251 fprintf(stderr, "Warning: `.' missing from directory %s\n",
252 pname);
253 if (dp != NULL && strcmp(dp->d_name, "..") == 0)
254 dp = rst_readdir(dirpg); /* first real entry */
255 else
256 fprintf(stderr, "Warning: `..' missing from directory %s\n",
257 pname);
258 bpt = rst_telldir(dirpg);
259 /*
260 * a zero inode signals end of directory
261 */
262 while (dp != NULL) {
263 locname[namelen] = '\0';
264 if ((size_t)(namelen + dp->d_namlen) >= sizeof(locname)) {
265 fprintf(stderr, "%s%s: name exceeds %zu char\n",
266 locname, dp->d_name, sizeof(locname) - 1);
267 } else {
268 strncat(locname, dp->d_name, (int)dp->d_namlen);
269 treescan(locname, dp->d_ino, todo);
270 rst_seekdir(dirpg, bpt, itp->t_seekpt);
271 }
272 dp = rst_readdir(dirpg);
273 bpt = rst_telldir(dirpg);
274 }
275 }
276
277 /*
278 * Lookup a pathname which is always assumed to start from the UFS_ROOTINO.
279 */
280 struct direct *
pathsearch(const char * pathname)281 pathsearch(const char *pathname)
282 {
283 ufs1_ino_t ino;
284 struct direct *dp;
285 char *path, *name, buffer[MAXPATHLEN];
286
287 strcpy(buffer, pathname);
288 path = buffer;
289 ino = UFS_ROOTINO;
290 while (*path == '/')
291 path++;
292 dp = NULL;
293 while ((name = strsep(&path, "/")) != NULL && *name != '\0') {
294 if ((dp = searchdir(ino, name)) == NULL)
295 return (NULL);
296 ino = dp->d_ino;
297 }
298 return (dp);
299 }
300
301 /*
302 * Lookup the requested name in directory inum.
303 * Return its inode number if found, zero if it does not exist.
304 */
305 static struct direct *
searchdir(ufs1_ino_t inum,char * name)306 searchdir(ufs1_ino_t inum, char *name)
307 {
308 struct direct *dp;
309 struct inotab *itp;
310 int len;
311
312 itp = inotablookup(inum);
313 if (itp == NULL)
314 return (NULL);
315 rst_seekdir(dirpg, itp->t_seekpt, itp->t_seekpt);
316 len = strlen(name);
317 do {
318 dp = rst_readdir(dirpg);
319 if (dp == NULL)
320 return (NULL);
321 } while (dp->d_namlen != len || strncmp(dp->d_name, name, len) != 0);
322 return (dp);
323 }
324
325 /*
326 * Put the directory entries in the directory file
327 */
328 static void
putdir(char * buf,size_t size)329 putdir(char *buf, size_t size)
330 {
331 struct direct cvtbuf;
332 struct odirect *odp;
333 struct odirect *eodp;
334 struct direct *dp;
335 size_t loc, i;
336
337 if (cvtflag) {
338 eodp = (struct odirect *)&buf[size];
339 for (odp = (struct odirect *)buf; odp < eodp; odp++)
340 if (odp->d_ino != 0) {
341 dcvt(odp, &cvtbuf);
342 putent(&cvtbuf);
343 }
344 } else {
345 for (loc = 0; loc < size; ) {
346 dp = (struct direct *)(buf + loc);
347 if (Bcvt)
348 swabst("ls", (u_char *) dp);
349 if (oldinofmt && dp->d_ino != 0) {
350 # if BYTE_ORDER == BIG_ENDIAN
351 if (Bcvt)
352 dp->d_namlen = dp->d_type;
353 # else
354 if (!Bcvt)
355 dp->d_namlen = dp->d_type;
356 # endif
357 dp->d_type = DT_UNKNOWN;
358 }
359 i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1));
360 if ((dp->d_reclen & 0x3) != 0 ||
361 dp->d_reclen > i ||
362 dp->d_reclen < DIRSIZ(0, dp)
363 #if NAME_MAX < 255
364 || dp->d_namlen > NAME_MAX
365 #endif
366 ) {
367 vprintf(stdout, "Mangled directory: ");
368 if ((dp->d_reclen & 0x3) != 0)
369 vprintf(stdout,
370 "reclen not multiple of 4 ");
371 if (dp->d_reclen < DIRSIZ(0, dp))
372 vprintf(stdout,
373 "reclen less than DIRSIZ (%u < %zu) ",
374 dp->d_reclen, DIRSIZ(0, dp));
375 #if NAME_MAX < 255
376 if (dp->d_namlen > NAME_MAX)
377 vprintf(stdout,
378 "reclen name too big (%u > %u) ",
379 dp->d_namlen, NAME_MAX);
380 #endif
381 vprintf(stdout, "\n");
382 loc += i;
383 continue;
384 }
385 loc += dp->d_reclen;
386 if (dp->d_ino != 0) {
387 putent(dp);
388 }
389 }
390 }
391 }
392
393 /*
394 * These variables are "local" to the following two functions.
395 */
396 char dirbuf[DIRBLKSIZ];
397 long dirloc = 0;
398 long prev = 0;
399
400 /*
401 * add a new directory entry to a file.
402 */
403 static void
putent(struct direct * dp)404 putent(struct direct *dp)
405 {
406 dp->d_reclen = DIRSIZ(0, dp);
407 if (dirloc + dp->d_reclen > DIRBLKSIZ) {
408 ((struct direct *)(dirbuf + prev))->d_reclen =
409 DIRBLKSIZ - prev;
410 fwrite(dirbuf, 1, DIRBLKSIZ, df);
411 dirloc = 0;
412 }
413 memmove(dirbuf + dirloc, dp, (long)dp->d_reclen);
414 prev = dirloc;
415 dirloc += dp->d_reclen;
416 }
417
418 /*
419 * flush out a directory that is finished.
420 */
421 static void
flushent(void)422 flushent(void)
423 {
424 ((struct direct *)(dirbuf + prev))->d_reclen = DIRBLKSIZ - prev;
425 fwrite(dirbuf, (int)dirloc, 1, df);
426 seekptg = ftell(df);
427 dirloc = 0;
428 }
429
430 static void
dcvt(struct odirect * odp,struct direct * ndp)431 dcvt(struct odirect *odp, struct direct *ndp)
432 {
433
434 memset(ndp, 0, (long)(sizeof *ndp));
435 ndp->d_ino = odp->d_ino;
436 ndp->d_type = DT_UNKNOWN;
437 strncpy(ndp->d_name, odp->d_name, ODIRSIZ);
438 ndp->d_namlen = strlen(ndp->d_name);
439 ndp->d_reclen = DIRSIZ(0, ndp);
440 }
441
442 /*
443 * Seek to an entry in a directory.
444 * Only values returned by rst_telldir should be passed to rst_seekdir.
445 * This routine handles many directories in a single file.
446 * It takes the base of the directory in the file, plus
447 * the desired seek offset into it.
448 */
449 static void
rst_seekdir(RST_DIR * dirpl,long loc,long base)450 rst_seekdir(RST_DIR *dirpl, long loc, long base)
451 {
452
453 if (loc == rst_telldir(dirpl))
454 return;
455 loc -= base;
456 if (loc < 0)
457 fprintf(stderr, "bad seek pointer to rst_seekdir %ld\n", loc);
458 lseek(dirpl->dd_fd, base + rounddown2(loc, DIRBLKSIZ), SEEK_SET);
459 dirpl->dd_loc = loc & (DIRBLKSIZ - 1);
460 if (dirpl->dd_loc != 0)
461 dirpl->dd_size = read(dirpl->dd_fd, dirpl->dd_buf, DIRBLKSIZ);
462 }
463
464 /*
465 * get next entry in a directory.
466 */
467 struct direct *
rst_readdir(RST_DIR * dirpl)468 rst_readdir(RST_DIR *dirpl)
469 {
470 struct direct *dp;
471
472 for (;;) {
473 if (dirpl->dd_loc == 0) {
474 dirpl->dd_size = read(dirpl->dd_fd, dirpl->dd_buf,
475 DIRBLKSIZ);
476 if (dirpl->dd_size <= 0) {
477 dprintf(stderr, "error reading directory\n");
478 return (NULL);
479 }
480 }
481 if (dirpl->dd_loc >= dirpl->dd_size) {
482 dirpl->dd_loc = 0;
483 continue;
484 }
485 dp = (struct direct *)(dirpl->dd_buf + dirpl->dd_loc);
486 if (dp->d_reclen == 0 ||
487 dp->d_reclen > DIRBLKSIZ + 1 - dirpl->dd_loc) {
488 dprintf(stderr, "corrupted directory: bad reclen %d\n",
489 dp->d_reclen);
490 return (NULL);
491 }
492 dirpl->dd_loc += dp->d_reclen;
493 if (dp->d_ino == 0 && strcmp(dp->d_name, "/") == 0)
494 return (NULL);
495 if (dp->d_ino >= maxino) {
496 dprintf(stderr, "corrupted directory: bad inum %d\n",
497 dp->d_ino);
498 continue;
499 }
500 return (dp);
501 }
502 }
503
504 /*
505 * Simulate the opening of a directory
506 */
507 RST_DIR *
rst_opendir(const char * name)508 rst_opendir(const char *name)
509 {
510 struct inotab *itp;
511 RST_DIR *dirpl;
512 ufs1_ino_t ino;
513
514 if ((ino = dirlookup(name)) > 0 &&
515 (itp = inotablookup(ino)) != NULL) {
516 dirpl = opendirfile(dirfile);
517 rst_seekdir(dirpl, itp->t_seekpt, itp->t_seekpt);
518 return (dirpl);
519 }
520 return (NULL);
521 }
522
523 /*
524 * In our case, there is nothing to do when closing a directory.
525 */
526 void
rst_closedir(RST_DIR * dirpl)527 rst_closedir(RST_DIR *dirpl)
528 {
529
530 close(dirpl->dd_fd);
531 free(dirpl);
532 return;
533 }
534
535 /*
536 * Simulate finding the current offset in the directory.
537 */
538 static long
rst_telldir(RST_DIR * dirpl)539 rst_telldir(RST_DIR *dirpl)
540 {
541 return ((long)lseek(dirpl->dd_fd,
542 (off_t)0, SEEK_CUR) - dirpl->dd_size + dirpl->dd_loc);
543 }
544
545 /*
546 * Open a directory file.
547 */
548 static RST_DIR *
opendirfile(const char * name)549 opendirfile(const char *name)
550 {
551 RST_DIR *dirpl;
552 int fd;
553
554 if ((fd = open(name, O_RDONLY)) == -1)
555 return (NULL);
556 if ((dirpl = malloc(sizeof(RST_DIR))) == NULL) {
557 close(fd);
558 return (NULL);
559 }
560 dirpl->dd_fd = fd;
561 dirpl->dd_loc = 0;
562 return (dirpl);
563 }
564
565 /*
566 * Set the mode, owner, and times for all new or changed directories
567 */
568 void
setdirmodes(int flags)569 setdirmodes(int flags)
570 {
571 FILE *mfl;
572 struct modeinfo node;
573 struct entry *ep;
574 char *cp;
575 const char *tmpdir;
576
577 vprintf(stdout, "Set directory mode, owner, and times.\n");
578 if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0')
579 tmpdir = _PATH_TMP;
580 if (command == 'r' || command == 'R')
581 sprintf(modefile, "%s/rstmode%ld", tmpdir, (long)dumpdate);
582 if (modefile[0] == '#') {
583 panic("modefile not defined\n");
584 fprintf(stderr, "directory mode, owner, and times not set\n");
585 return;
586 }
587 mfl = fopen(modefile, "r");
588 if (mfl == NULL) {
589 fprintf(stderr, "fopen: %s\n", strerror(errno));
590 fprintf(stderr, "cannot open mode file %s\n", modefile);
591 fprintf(stderr, "directory mode, owner, and times not set\n");
592 return;
593 }
594 clearerr(mfl);
595 for (;;) {
596 fread((char *)&node, 1, sizeof(struct modeinfo), mfl);
597 if (feof(mfl))
598 break;
599 ep = lookupino(node.ino);
600 if (command == 'i' || command == 'x') {
601 if (ep == NULL)
602 continue;
603 if ((flags & FORCE) == 0 && ep->e_flags & EXISTED) {
604 ep->e_flags &= ~NEW;
605 continue;
606 }
607 if (node.ino == UFS_ROOTINO &&
608 reply("set owner/mode for '.'") == FAIL)
609 continue;
610 }
611 if (ep == NULL) {
612 panic("cannot find directory inode %d\n", node.ino);
613 } else {
614 cp = myname(ep);
615 if (!Nflag) {
616 chown(cp, node.uid, node.gid);
617 chmod(cp, node.mode);
618 utimes(cp, node.timep);
619 chflags(cp, node.flags);
620 }
621 ep->e_flags &= ~NEW;
622 }
623 }
624 if (ferror(mfl))
625 panic("error setting directory modes\n");
626 fclose(mfl);
627 }
628
629 /*
630 * Generate a literal copy of a directory.
631 */
632 int
genliteraldir(char * name,ufs1_ino_t ino)633 genliteraldir(char *name, ufs1_ino_t ino)
634 {
635 struct inotab *itp;
636 int ofile, dp, i, size;
637 char buf[BUFSIZ];
638
639 itp = inotablookup(ino);
640 if (itp == NULL)
641 panic("Cannot find directory inode %d named %s\n", ino, name);
642 if ((ofile = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0) {
643 fprintf(stderr, "%s: ", name);
644 fflush(stderr);
645 fprintf(stderr, "cannot create file: %s\n", strerror(errno));
646 return (FAIL);
647 }
648 rst_seekdir(dirpg, itp->t_seekpt, itp->t_seekpt);
649 dp = dup(dirpg->dd_fd);
650 for (i = itp->t_size; i > 0; i -= BUFSIZ) {
651 size = i < BUFSIZ ? i : BUFSIZ;
652 if (read(dp, buf, (int) size) == -1) {
653 fprintf(stderr,
654 "write error extracting inode %d, name %s\n",
655 curfile.ino, curfile.name);
656 fprintf(stderr, "read: %s\n", strerror(errno));
657 done(1);
658 }
659 if (!Nflag && write(ofile, buf, (int) size) == -1) {
660 fprintf(stderr,
661 "write error extracting inode %d, name %s\n",
662 curfile.ino, curfile.name);
663 fprintf(stderr, "write: %s\n", strerror(errno));
664 done(1);
665 }
666 }
667 close(dp);
668 close(ofile);
669 return (GOOD);
670 }
671
672 /*
673 * Determine the type of an inode
674 */
675 int
inodetype(ufs1_ino_t ino)676 inodetype(ufs1_ino_t ino)
677 {
678 struct inotab *itp;
679
680 itp = inotablookup(ino);
681 if (itp == NULL)
682 return (LEAF);
683 return (NODE);
684 }
685
686 /*
687 * Allocate and initialize a directory inode entry.
688 * If requested, save its pertinent mode, owner, and time info.
689 */
690 static struct inotab *
allocinotab(ufs1_ino_t ino,struct ufs1_dinode * dip,long seekptl)691 allocinotab(ufs1_ino_t ino, struct ufs1_dinode *dip, long seekptl)
692 {
693 struct inotab *itp;
694 struct modeinfo node;
695
696 itp = calloc(1, sizeof(struct inotab));
697 if (itp == NULL)
698 panic("no memory directory table\n");
699 itp->t_next = inotab[INOHASH(ino)];
700 inotab[INOHASH(ino)] = itp;
701 itp->t_ino = ino;
702 itp->t_seekpt = seekptl;
703 if (mfg == NULL)
704 return (itp);
705 node.ino = ino;
706 node.timep[0].tv_sec = dip->di_atime;
707 node.timep[0].tv_usec = dip->di_atimensec / 1000;
708 node.timep[1].tv_sec = dip->di_mtime;
709 node.timep[1].tv_usec = dip->di_mtimensec / 1000;
710 node.mode = dip->di_mode;
711 node.flags = dip->di_flags;
712 node.uid = dip->di_uid;
713 node.gid = dip->di_gid;
714 fwrite((char *)&node, 1, sizeof(struct modeinfo), mfg);
715 return (itp);
716 }
717
718 /*
719 * Look up an inode in the table of directories
720 */
721 static struct inotab *
inotablookup(ufs1_ino_t ino)722 inotablookup(ufs1_ino_t ino)
723 {
724 struct inotab *itp;
725
726 for (itp = inotab[INOHASH(ino)]; itp != NULL; itp = itp->t_next)
727 if (itp->t_ino == ino)
728 return (itp);
729 return (NULL);
730 }
731
732 /*
733 * Clean up and exit
734 */
735 void
done(int exitcode)736 done(int exitcode)
737 {
738
739 closemt();
740 if (modefile[0] != '#')
741 unlink(modefile);
742 if (dirfile[0] != '#')
743 unlink(dirfile);
744 exit(exitcode);
745 }
746