A number of structures related to UFS and QUOTAS have changed name.
[dragonfly.git] / sbin / restore / dirs.c
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. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  * @(#)dirs.c   8.7 (Berkeley) 5/1/95
39  * $FreeBSD: src/sbin/restore/dirs.c,v 1.14.2.5 2001/10/15 13:44:45 dd Exp $
40  * $DragonFly: src/sbin/restore/dirs.c,v 1.10 2006/04/03 01:58:49 dillon Exp $
41  */
42
43 #include <sys/param.h>
44 #include <sys/file.h>
45 #include <sys/stat.h>
46 #include <sys/time.h>
47
48 #include <vfs/ufs/dinode.h>
49 #include <vfs/ufs/dir.h>
50 #include <protocols/dumprestore.h>
51
52 #include <err.h>
53 #include <errno.h>
54 #include <paths.h>
55 #include <stdio.h>
56 #include <stdlib.h>
57 #include <string.h>
58 #include <unistd.h>
59
60 #include "restore.h"
61 #include "extern.h"
62
63 /*
64  * Symbol table of directories read from tape.
65  */
66 #define HASHSIZE        1000
67 #define INOHASH(val) (val % HASHSIZE)
68 struct inotab {
69         struct  inotab *t_next;
70         ufs1_ino_t      t_ino;
71         int32_t t_seekpt;
72         int32_t t_size;
73 };
74 static struct inotab *inotab[HASHSIZE];
75
76 /*
77  * Information retained about directories.
78  */
79 struct modeinfo {
80         ufs1_ino_t ino;
81         struct timeval timep[2];
82         mode_t mode;
83         uid_t uid;
84         gid_t gid;
85         int flags;
86 };
87
88 /*
89  * Definitions for library routines operating on directories.
90  */
91 #undef DIRBLKSIZ
92 #define DIRBLKSIZ 1024
93 struct rstdirdesc {
94         int     dd_fd;
95         int32_t dd_loc;
96         int32_t dd_size;
97         char    dd_buf[DIRBLKSIZ];
98 };
99
100 /*
101  * Global variables for this file.
102  */
103 static long     seekpt;
104 static FILE     *df, *mf;
105 static RST_DIR  *dirp;
106 static char     dirfile[MAXPATHLEN] = "#";      /* No file */
107 static char     modefile[MAXPATHLEN] = "#";     /* No file */
108 static char     dot[2] = ".";                   /* So it can be modified */
109
110 /*
111  * Format of old style directories.
112  */
113 #define ODIRSIZ 14
114 struct odirect {
115         u_short d_ino;
116         char    d_name[ODIRSIZ];
117 };
118
119 static struct inotab    *allocinotab(ufs1_ino_t, struct ufs1_dinode *, long);
120 static void              dcvt(struct odirect *, struct direct *);
121 static void              flushent(void);
122 static struct inotab    *inotablookup(ufs1_ino_t);
123 static RST_DIR          *opendirfile(const char *);
124 static void              putdir(char *, long);
125 static void              putent(struct direct *);
126 static void              rst_seekdir(RST_DIR *, long, long);
127 static long              rst_telldir(RST_DIR *);
128 static struct direct    *searchdir(ufs1_ino_t, char *);
129
130 /*
131  *      Extract directory contents, building up a directory structure
132  *      on disk for extraction by name.
133  *      If genmode is requested, save mode, owner, and times for all
134  *      directories on the tape.
135  */
136 void
137 extractdirs(int genmode)
138 {
139         int i;
140         struct ufs1_dinode *ip;
141         struct inotab *itp;
142         struct direct nulldir;
143         int fd;
144         const char *tmpdir;
145
146         vprintf(stdout, "Extract directories from tape\n");
147         if ((tmpdir = getenv("TMPDIR")) == NULL || tmpdir[0] == '\0')
148                 tmpdir = _PATH_TMP;
149         sprintf(dirfile, "%s/rstdir%ld", tmpdir, (long)dumpdate);
150         if (command != 'r' && command != 'R') {
151                 (void *) strcat(dirfile, "-XXXXXX");
152                 fd = mkstemp(dirfile);
153         } else
154                 fd = open(dirfile, O_RDWR|O_CREAT|O_EXCL, 0666);
155         if (fd == -1 || (df = fdopen(fd, "w")) == NULL) {
156                 if (fd != -1)
157                         close(fd);
158                 warn("%s - cannot create directory temporary\nfopen", dirfile);
159                 done(1);
160         }
161         if (genmode != 0) {
162                 sprintf(modefile, "%s/rstmode%ld", tmpdir, (long)dumpdate);
163                 if (command != 'r' && command != 'R') {
164                         (void *) strcat(modefile, "-XXXXXX");
165                         fd = mkstemp(modefile);
166                 } else
167                         fd = open(modefile, O_RDWR|O_CREAT|O_EXCL, 0666);
168                 if (fd == -1 || (mf = fdopen(fd, "w")) == NULL) {
169                         if (fd != -1)
170                                 close(fd);
171                         warn("%s - cannot create modefile\nfopen", modefile);
172                         done(1);
173                 }
174         }
175         nulldir.d_ino = 0;
176         nulldir.d_type = DT_DIR;
177         nulldir.d_namlen = 1;
178         strcpy(nulldir.d_name, "/");
179         nulldir.d_reclen = DIRSIZ(0, &nulldir);
180         for (;;) {
181                 curfile.name = "<directory file - name unknown>";
182                 curfile.action = USING;
183                 ip = curfile.dip;
184                 if (ip == NULL || (ip->di_mode & IFMT) != IFDIR) {
185                         fclose(df);
186                         dirp = opendirfile(dirfile);
187                         if (dirp == NULL)
188                                 fprintf(stderr, "opendirfile: %s\n",
189                                     strerror(errno));
190                         if (mf != NULL)
191                                 fclose(mf);
192                         i = dirlookup(dot);
193                         if (i == 0)
194                                 panic("Root directory is not on tape\n");
195                         return;
196                 }
197                 itp = allocinotab(curfile.ino, ip, seekpt);
198                 getfile(putdir, xtrnull);
199                 putent(&nulldir);
200                 flushent();
201                 itp->t_size = seekpt - itp->t_seekpt;
202         }
203 }
204
205 /*
206  * skip over all the directories on the tape
207  */
208 void
209 skipdirs(void)
210 {
211
212         while (curfile.dip && (curfile.dip->di_mode & IFMT) == IFDIR) {
213                 skipfile();
214         }
215 }
216
217 /*
218  *      Recursively find names and inumbers of all files in subtree
219  *      pname and pass them off to be processed.
220  */
221 void
222 treescan(char *pname, ufs1_ino_t ino, long (*todo) (char *, ufs1_ino_t, int))
223 {
224         struct inotab *itp;
225         struct direct *dp;
226         int namelen;
227         long bpt;
228         char locname[MAXPATHLEN + 1];
229
230         itp = inotablookup(ino);
231         if (itp == NULL) {
232                 /*
233                  * Pname is name of a simple file or an unchanged directory.
234                  */
235                 (*todo)(pname, ino, LEAF);
236                 return;
237         }
238         /*
239          * Pname is a dumped directory name.
240          */
241         if ((*todo)(pname, ino, NODE) == FAIL)
242                 return;
243         /*
244          * begin search through the directory
245          * skipping over "." and ".."
246          */
247         strncpy(locname, pname, sizeof(locname) - 1);
248         locname[sizeof(locname) - 1] = '\0';
249         strncat(locname, "/", sizeof(locname) - strlen(locname));
250         namelen = strlen(locname);
251         rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
252         dp = rst_readdir(dirp); /* "." */
253         if (dp != NULL && strcmp(dp->d_name, ".") == 0)
254                 dp = rst_readdir(dirp); /* ".." */
255         else
256                 fprintf(stderr, "Warning: `.' missing from directory %s\n",
257                         pname);
258         if (dp != NULL && strcmp(dp->d_name, "..") == 0)
259                 dp = rst_readdir(dirp); /* first real entry */
260         else
261                 fprintf(stderr, "Warning: `..' missing from directory %s\n",
262                         pname);
263         bpt = rst_telldir(dirp);
264         /*
265          * a zero inode signals end of directory
266          */
267         while (dp != NULL) {
268                 locname[namelen] = '\0';
269                 if (namelen + dp->d_namlen >= sizeof(locname)) {
270                         fprintf(stderr, "%s%s: name exceeds %d char\n",
271                                 locname, dp->d_name, sizeof(locname) - 1);
272                 } else {
273                         strncat(locname, dp->d_name, (int)dp->d_namlen);
274                         treescan(locname, dp->d_ino, todo);
275                         rst_seekdir(dirp, bpt, itp->t_seekpt);
276                 }
277                 dp = rst_readdir(dirp);
278                 bpt = rst_telldir(dirp);
279         }
280 }
281
282 /*
283  * Lookup a pathname which is always assumed to start from the ROOTINO.
284  */
285 struct direct *
286 pathsearch(const char *pathname)
287 {
288         ufs1_ino_t ino;
289         struct direct *dp;
290         char *path, *name, buffer[MAXPATHLEN];
291
292         strcpy(buffer, pathname);
293         path = buffer;
294         ino = ROOTINO;
295         while (*path == '/')
296                 path++;
297         dp = NULL;
298         while ((name = strsep(&path, "/")) != NULL && *name != '\0') {
299                 if ((dp = searchdir(ino, name)) == NULL)
300                         return (NULL);
301                 ino = dp->d_ino;
302         }
303         return (dp);
304 }
305
306 /*
307  * Lookup the requested name in directory inum.
308  * Return its inode number if found, zero if it does not exist.
309  */
310 static struct direct *
311 searchdir(ufs1_ino_t inum, char *name)
312 {
313         struct direct *dp;
314         struct inotab *itp;
315         int len;
316
317         itp = inotablookup(inum);
318         if (itp == NULL)
319                 return (NULL);
320         rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
321         len = strlen(name);
322         do {
323                 dp = rst_readdir(dirp);
324                 if (dp == NULL)
325                         return (NULL);
326         } while (dp->d_namlen != len || strncmp(dp->d_name, name, len) != 0);
327         return (dp);
328 }
329
330 /*
331  * Put the directory entries in the directory file
332  */
333 static void
334 putdir(char *buf, long size)
335 {
336         struct direct cvtbuf;
337         struct odirect *odp;
338         struct odirect *eodp;
339         struct direct *dp;
340         long loc, i;
341
342         if (cvtflag) {
343                 eodp = (struct odirect *)&buf[size];
344                 for (odp = (struct odirect *)buf; odp < eodp; odp++)
345                         if (odp->d_ino != 0) {
346                                 dcvt(odp, &cvtbuf);
347                                 putent(&cvtbuf);
348                         }
349         } else {
350                 for (loc = 0; loc < size; ) {
351                         dp = (struct direct *)(buf + loc);
352                         if (Bcvt)
353                                 swabst((u_char *)"ls", (u_char *) dp);
354                         if (oldinofmt && dp->d_ino != 0) {
355 #                               if BYTE_ORDER == BIG_ENDIAN
356                                         if (Bcvt)
357                                                 dp->d_namlen = dp->d_type;
358 #                               else
359                                         if (!Bcvt)
360                                                 dp->d_namlen = dp->d_type;
361 #                               endif
362                                 dp->d_type = DT_UNKNOWN;
363                         }
364                         i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1));
365                         if ((dp->d_reclen & 0x3) != 0 ||
366                             dp->d_reclen > i ||
367                             dp->d_reclen < DIRSIZ(0, dp) ||
368                             dp->d_namlen > NAME_MAX) {
369                                 vprintf(stdout, "Mangled directory: ");
370                                 if ((dp->d_reclen & 0x3) != 0)
371                                         vprintf(stdout,
372                                            "reclen not multiple of 4 ");
373                                 if (dp->d_reclen < DIRSIZ(0, dp))
374                                         vprintf(stdout,
375                                            "reclen less than DIRSIZ (%d < %d) ",
376                                            dp->d_reclen, DIRSIZ(0, dp));
377                                 if (dp->d_namlen > NAME_MAX)
378                                         vprintf(stdout,
379                                            "reclen name too big (%d > %d) ",
380                                            dp->d_namlen, NAME_MAX);
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
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
422 flushent(void)
423 {
424         ((struct direct *)(dirbuf + prev))->d_reclen = DIRBLKSIZ - prev;
425         fwrite(dirbuf, (int)dirloc, 1, df);
426         seekpt = ftell(df);
427         dirloc = 0;
428 }
429
430 static void
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
450 rst_seekdir(RST_DIR *dirp, long loc, long base)
451 {
452
453         if (loc == rst_telldir(dirp))
454                 return;
455         loc -= base;
456         if (loc < 0)
457                 fprintf(stderr, "bad seek pointer to rst_seekdir %ld\n", loc);
458         lseek(dirp->dd_fd, base + (loc & ~(DIRBLKSIZ - 1)), SEEK_SET);
459         dirp->dd_loc = loc & (DIRBLKSIZ - 1);
460         if (dirp->dd_loc != 0)
461                 dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ);
462 }
463
464 /*
465  * get next entry in a directory.
466  */
467 struct direct *
468 rst_readdir(RST_DIR *dirp)
469 {
470         struct direct *dp;
471
472         for (;;) {
473                 if (dirp->dd_loc == 0) {
474                         dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf,
475                             DIRBLKSIZ);
476                         if (dirp->dd_size <= 0) {
477                                 dprintf(stderr, "error reading directory\n");
478                                 return (NULL);
479                         }
480                 }
481                 if (dirp->dd_loc >= dirp->dd_size) {
482                         dirp->dd_loc = 0;
483                         continue;
484                 }
485                 dp = (struct direct *)(dirp->dd_buf + dirp->dd_loc);
486                 if (dp->d_reclen == 0 ||
487                     dp->d_reclen > DIRBLKSIZ + 1 - dirp->dd_loc) {
488                         dprintf(stderr, "corrupted directory: bad reclen %d\n",
489                                 dp->d_reclen);
490                         return (NULL);
491                 }
492                 dirp->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 *
508 rst_opendir(const char *name)
509 {
510         struct inotab *itp;
511         RST_DIR *dirp;
512         ufs1_ino_t ino;
513
514         if ((ino = dirlookup(name)) > 0 &&
515             (itp = inotablookup(ino)) != NULL) {
516                 dirp = opendirfile(dirfile);
517                 rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
518                 return (dirp);
519         }
520         return (NULL);
521 }
522
523 /*
524  * In our case, there is nothing to do when closing a directory.
525  */
526 void
527 rst_closedir(RST_DIR *dirp)
528 {
529
530         close(dirp->dd_fd);
531         free(dirp);
532         return;
533 }
534
535 /*
536  * Simulate finding the current offset in the directory.
537  */
538 static long
539 rst_telldir(RST_DIR *dirp)
540 {
541         return ((long)lseek(dirp->dd_fd,
542             (off_t)0, SEEK_CUR) - dirp->dd_size + dirp->dd_loc);
543 }
544
545 /*
546  * Open a directory file.
547  */
548 static RST_DIR *
549 opendirfile(const char *name)
550 {
551         RST_DIR *dirp;
552         int fd;
553
554         if ((fd = open(name, O_RDONLY)) == -1)
555                 return (NULL);
556         if ((dirp = malloc(sizeof(RST_DIR))) == NULL) {
557                 close(fd);
558                 return (NULL);
559         }
560         dirp->dd_fd = fd;
561         dirp->dd_loc = 0;
562         return (dirp);
563 }
564
565 /*
566  * Set the mode, owner, and times for all new or changed directories
567  */
568 void
569 setdirmodes(int flags)
570 {
571         FILE *mf;
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         mf = fopen(modefile, "r");
588         if (mf == 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(mf);
595         for (;;) {
596                 fread((char *)&node, 1, sizeof(struct modeinfo), mf);
597                 if (feof(mf))
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 == 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(mf))
625                 panic("error setting directory modes\n");
626         fclose(mf);
627 }
628
629 /*
630  * Generate a literal copy of a directory.
631  */
632 int
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(dirp, itp->t_seekpt, itp->t_seekpt);
649         dp = dup(dirp->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
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 *
691 allocinotab(ufs1_ino_t ino, struct ufs1_dinode *dip, long seekpt)
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 = seekpt;
703         if (mf == 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), mf);
715         return (itp);
716 }
717
718 /*
719  * Look up an inode in the table of directories
720  */
721 static struct inotab *
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
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 }