386BSD 0.1 development
[unix-history] / usr / src / sbin / restore / dirs.c
index e0d87de..b2c00f9 100644 (file)
@@ -1,13 +1,45 @@
-/* Copyright (c) 1983 Regents of the University of California */
+/*
+ * Copyright (c) 1983 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
 
 #ifndef lint
 
 #ifndef lint
-static char sccsid[] = "@(#)dirs.c     3.10    (Berkeley)      83/05/14";
-#endif
+static char sccsid[] = "@(#)dirs.c     5.15 (Berkeley) 2/26/91";
+#endif /* not lint */
 
 #include "restore.h"
 
 #include "restore.h"
-#include <dumprestor.h>
+#include <protocols/dumprestore.h>
 #include <sys/file.h>
 #include <sys/file.h>
-#include <dir.h>
+#include <ufs/dir.h>
+#include "pathnames.h"
 
 /*
  * Symbol table of directories read from tape.
 
 /*
  * Symbol table of directories read from tape.
@@ -29,12 +61,27 @@ extern struct inotab *allocinotab();
  */
 struct modeinfo {
        ino_t ino;
  */
 struct modeinfo {
        ino_t ino;
-       time_t timep[2];
+       struct timeval timep[2];
        short mode;
        short uid;
        short gid;
 };
 
        short mode;
        short uid;
        short gid;
 };
 
+/*
+ * Definitions for library routines operating on directories.
+ */
+#undef DIRBLKSIZ
+#define DIRBLKSIZ 1024
+struct dirdesc {
+       int     dd_fd;
+       long    dd_loc;
+       long    dd_size;
+       char    dd_buf[DIRBLKSIZ];
+};
+extern DIR *opendirfile();
+extern off_t rst_telldir();
+extern void rst_seekdir();
+
 /*
  * Global variables for this file.
  */
 /*
  * Global variables for this file.
  */
@@ -43,7 +90,10 @@ static FILE  *df, *mf;
 static DIR     *dirp;
 static char    dirfile[32] = "#";      /* No file */
 static char    modefile[32] = "#";     /* No file */
 static DIR     *dirp;
 static char    dirfile[32] = "#";      /* No file */
 static char    modefile[32] = "#";     /* No file */
+static char    dot[2] = ".";           /* So it can be modified */
 extern ino_t   search();
 extern ino_t   search();
+struct direct  *rst_readdir();
+extern void    rst_seekdir();
 
 /*
  * Format of old style directories.
 
 /*
  * Format of old style directories.
@@ -54,18 +104,6 @@ struct odirect {
        char    d_name[ODIRSIZ];
 };
 
        char    d_name[ODIRSIZ];
 };
 
-/*
- * Structure and routines associated with listing directories.
- */
-struct afile {
-       ino_t   fnum;           /* inode number of file */
-       char    *fname;         /* file name */
-       short   fflags;         /* extraction flags, if any */
-       char    ftype;          /* file type, e.g. LEAF or NODE */
-};
-extern int fcmp();
-extern char *fmtentry();
-
 /*
  *     Extract directory contents, building up a directory structure
  *     on disk for extraction by name.
 /*
  *     Extract directory contents, building up a directory structure
  *     on disk for extraction by name.
@@ -82,21 +120,21 @@ extractdirs(genmode)
        int putdir(), null();
 
        vprintf(stdout, "Extract directories from tape\n");
        int putdir(), null();
 
        vprintf(stdout, "Extract directories from tape\n");
-       (void) sprintf(dirfile, "/tmp/rstdir%d", dumpdate);
+       (void) sprintf(dirfile, "%s/rstdir%d", _PATH_TMP, dumpdate);
        df = fopen(dirfile, "w");
        if (df == 0) {
                fprintf(stderr,
        df = fopen(dirfile, "w");
        if (df == 0) {
                fprintf(stderr,
-                   "restor: %s - cannot create directory temporary\n",
+                   "restore: %s - cannot create directory temporary\n",
                    dirfile);
                perror("fopen");
                done(1);
        }
        if (genmode != 0) {
                    dirfile);
                perror("fopen");
                done(1);
        }
        if (genmode != 0) {
-               (void) sprintf(modefile, "/tmp/rstmode%d", dumpdate);
+               (void) sprintf(modefile, "%s/rstmode%d", _PATH_TMP, dumpdate);
                mf = fopen(modefile, "w");
                if (mf == 0) {
                        fprintf(stderr,
                mf = fopen(modefile, "w");
                if (mf == 0) {
                        fprintf(stderr,
-                           "restor: %s - cannot create modefile \n",
+                           "restore: %s - cannot create modefile \n",
                            modefile);
                        perror("fopen");
                        done(1);
                            modefile);
                        perror("fopen");
                        done(1);
@@ -110,15 +148,14 @@ extractdirs(genmode)
                curfile.name = "<directory file - name unknown>";
                curfile.action = USING;
                ip = curfile.dip;
                curfile.name = "<directory file - name unknown>";
                curfile.action = USING;
                ip = curfile.dip;
-               i = ip->di_mode & IFMT;
-               if (i != IFDIR) {
+               if (ip == NULL || (ip->di_mode & IFMT) != IFDIR) {
                        (void) fclose(df);
                        (void) fclose(df);
-                       dirp = opendir(dirfile);
+                       dirp = opendirfile(dirfile);
                        if (dirp == NULL)
                        if (dirp == NULL)
-                               perror("opendir");
+                               perror("opendirfile");
                        if (mf != NULL)
                                (void) fclose(mf);
                        if (mf != NULL)
                                (void) fclose(mf);
-                       i = dirlookup(".");
+                       i = dirlookup(dot);
                        if (i == 0)
                                panic("Root directory is not on tape\n");
                        return;
                        if (i == 0)
                                panic("Root directory is not on tape\n");
                        return;
@@ -178,25 +215,19 @@ treescan(pname, ino, todo)
        (void) strncpy(locname, pname, MAXPATHLEN);
        (void) strncat(locname, "/", MAXPATHLEN);
        namelen = strlen(locname);
        (void) strncpy(locname, pname, MAXPATHLEN);
        (void) strncat(locname, "/", MAXPATHLEN);
        namelen = strlen(locname);
-       seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
-       dp = readdir(dirp); /* "." */
-       if (dp != NULL && strcmp(dp->d_name, ".") == 0) {
-               dp = readdir(dirp); /* ".." */
-       } else {
-               np = lookupino(ino);
-               if (np == NULL)
-                       panic("corrupted symbol table\n");
-               fprintf(stderr, ". missing from directory %s\n", myname(np));
-       }
-       if (dp != NULL && strcmp(dp->d_name, "..") == 0) {
-               dp = readdir(dirp); /* first real entry */
-       } else {
-               np = lookupino(ino);
-               if (np == NULL)
-                       panic("corrupted symbol table\n");
-               fprintf(stderr, ".. missing from directory %s\n", myname(np));
-       }
-       bpt = telldir(dirp);
+       rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
+       dp = rst_readdir(dirp); /* "." */
+       if (dp != NULL && strcmp(dp->d_name, ".") == 0)
+               dp = rst_readdir(dirp); /* ".." */
+       else
+               fprintf(stderr, "Warning: `.' missing from directory %s\n",
+                       pname);
+       if (dp != NULL && strcmp(dp->d_name, "..") == 0)
+               dp = rst_readdir(dirp); /* first real entry */
+       else
+               fprintf(stderr, "Warning: `..' missing from directory %s\n",
+                       pname);
+       bpt = rst_telldir(dirp);
        /*
         * a zero inode signals end of directory
         */
        /*
         * a zero inode signals end of directory
         */
@@ -208,10 +239,10 @@ treescan(pname, ino, todo)
                } else {
                        (void) strncat(locname, dp->d_name, (int)dp->d_namlen);
                        treescan(locname, dp->d_ino, todo);
                } else {
                        (void) strncat(locname, dp->d_name, (int)dp->d_namlen);
                        treescan(locname, dp->d_ino, todo);
-                       seekdir(dirp, bpt, itp->t_seekpt);
+                       rst_seekdir(dirp, bpt, itp->t_seekpt);
                }
                }
-               dp = readdir(dirp);
-               bpt = telldir(dirp);
+               dp = rst_readdir(dirp);
+               bpt = rst_telldir(dirp);
        }
        if (dp == NULL)
                fprintf(stderr, "corrupted directory: %s.\n", locname);
        }
        if (dp == NULL)
                fprintf(stderr, "corrupted directory: %s.\n", locname);
@@ -267,10 +298,10 @@ search(inum, cp)
        itp = inotablookup(inum);
        if (itp == NULL)
                return(0);
        itp = inotablookup(inum);
        if (itp == NULL)
                return(0);
-       seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
+       rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
        len = strlen(cp);
        do {
        len = strlen(cp);
        do {
-               dp = readdir(dirp);
+               dp = rst_readdir(dirp);
                if (dp == NULL || dp->d_ino == 0)
                        return (0);
        } while (dp->d_namlen != len || strncmp(dp->d_name, cp, len) != 0);
                if (dp == NULL || dp->d_ino == 0)
                        return (0);
        } while (dp->d_namlen != len || strncmp(dp->d_name, cp, len) != 0);
@@ -289,6 +320,7 @@ putdir(buf, size)
        struct odirect *eodp;
        register struct direct *dp;
        long loc, i;
        struct odirect *eodp;
        register struct direct *dp;
        long loc, i;
+       extern int Bcvt;
 
        if (cvtflag) {
                eodp = (struct odirect *)&buf[size];
 
        if (cvtflag) {
                eodp = (struct odirect *)&buf[size];
@@ -300,8 +332,15 @@ putdir(buf, size)
        } else {
                for (loc = 0; loc < size; ) {
                        dp = (struct direct *)(buf + loc);
        } else {
                for (loc = 0; loc < size; ) {
                        dp = (struct direct *)(buf + loc);
+                       if (Bcvt) {
+                               swabst("l2s", (char *) dp);
+                       }
                        i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1));
                        i = DIRBLKSIZ - (loc & (DIRBLKSIZ - 1));
-                       if (dp->d_reclen == 0 || dp->d_reclen > i) {
+                       if ((dp->d_reclen & 0x3) != 0 ||
+                           dp->d_reclen > i ||
+                           dp->d_reclen < DIRSIZ(dp) ||
+                           dp->d_namlen > MAXNAMLEN) {
+                               vprintf(stdout, "Mangled directory\n");
                                loc += i;
                                continue;
                        }
                                loc += i;
                                continue;
                        }
@@ -364,22 +403,22 @@ dcvt(odp, ndp)
 
 /*
  * Seek to an entry in a directory.
 
 /*
  * Seek to an entry in a directory.
- * Only values returned by ``telldir'' should be passed to seekdir.
+ * Only values returned by rst_telldir should be passed to rst_seekdir.
  * This routine handles many directories in a single file.
  * It takes the base of the directory in the file, plus
  * the desired seek offset into it.
  */
 void
  * This routine handles many directories in a single file.
  * It takes the base of the directory in the file, plus
  * the desired seek offset into it.
  */
 void
-seekdir(dirp, loc, base)
+rst_seekdir(dirp, loc, base)
        register DIR *dirp;
        daddr_t loc, base;
 {
 
        register DIR *dirp;
        daddr_t loc, base;
 {
 
-       if (loc == telldir(dirp))
+       if (loc == rst_telldir(dirp))
                return;
        loc -= base;
        if (loc < 0)
                return;
        loc -= base;
        if (loc < 0)
-               fprintf(stderr, "bad seek pointer to seekdir %d\n", loc);
+               fprintf(stderr, "bad seek pointer to rst_seekdir %d\n", loc);
        (void) lseek(dirp->dd_fd, base + (loc & ~(DIRBLKSIZ - 1)), 0);
        dirp->dd_loc = loc & (DIRBLKSIZ - 1);
        if (dirp->dd_loc != 0)
        (void) lseek(dirp->dd_fd, base + (loc & ~(DIRBLKSIZ - 1)), 0);
        dirp->dd_loc = loc & (DIRBLKSIZ - 1);
        if (dirp->dd_loc != 0)
@@ -390,7 +429,7 @@ seekdir(dirp, loc, base)
  * get next entry in a directory.
  */
 struct direct *
  * get next entry in a directory.
  */
 struct direct *
-readdir(dirp)
+rst_readdir(dirp)
        register DIR *dirp;
 {
        register struct direct *dp;
        register DIR *dirp;
 {
        register struct direct *dp;
@@ -418,7 +457,7 @@ readdir(dirp)
                dirp->dd_loc += dp->d_reclen;
                if (dp->d_ino == 0 && strcmp(dp->d_name, "/") != 0)
                        continue;
                dirp->dd_loc += dp->d_reclen;
                if (dp->d_ino == 0 && strcmp(dp->d_name, "/") != 0)
                        continue;
-               if (dp->d_ino < 0 || dp->d_ino >= maxino) {
+               if (dp->d_ino >= maxino) {
                        dprintf(stderr, "corrupted directory: bad inum %d\n",
                                dp->d_ino);
                        continue;
                        dprintf(stderr, "corrupted directory: bad inum %d\n",
                                dp->d_ino);
                        continue;
@@ -427,6 +466,57 @@ readdir(dirp)
        }
 }
 
        }
 }
 
+/*
+ * Simulate the opening of a directory
+ */
+DIR *
+rst_opendir(name)
+       char *name;
+{
+       struct inotab *itp;
+       ino_t ino;
+
+       if ((ino = dirlookup(name)) > 0 &&
+           (itp = inotablookup(ino)) != NULL) {
+               rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
+               return (dirp);
+       }
+       return (0);
+}
+
+/*
+ * Simulate finding the current offset in the directory.
+ */
+off_t
+rst_telldir(dirp)
+       DIR *dirp;
+{
+       off_t lseek();
+
+       return (lseek(dirp->dd_fd, 0L, 1) - dirp->dd_size + dirp->dd_loc);
+}
+
+/*
+ * Open a directory file.
+ */
+DIR *
+opendirfile(name)
+       char *name;
+{
+       register DIR *dirp;
+       register int fd;
+
+       if ((fd = open(name, 0)) == -1)
+               return NULL;
+       if ((dirp = (DIR *)malloc(sizeof(DIR))) == NULL) {
+               close (fd);
+               return NULL;
+       }
+       dirp->dd_fd = fd;
+       dirp->dd_loc = 0;
+       return dirp;
+}
+
 /*
  * Set the mode, owner, and times for all new or changed directories
  */
 /*
  * Set the mode, owner, and times for all new or changed directories
  */
@@ -438,10 +528,13 @@ setdirmodes()
        char *cp;
        
        vprintf(stdout, "Set directory mode, owner, and times.\n");
        char *cp;
        
        vprintf(stdout, "Set directory mode, owner, and times.\n");
+       (void) sprintf(modefile, "%s/rstmode%d", _PATH_TMP, dumpdate);
        mf = fopen(modefile, "r");
        if (mf == NULL) {
                perror("fopen");
        mf = fopen(modefile, "r");
        if (mf == NULL) {
                perror("fopen");
-               panic("cannot open mode file %s\n", modefile);
+               fprintf(stderr, "cannot open mode file %s\n", modefile);
+               fprintf(stderr, "directory mode, owner, and times not set\n");
+               return;
        }
        clearerr(mf);
        for (;;) {
        }
        clearerr(mf);
        for (;;) {
@@ -449,16 +542,26 @@ setdirmodes()
                if (feof(mf))
                        break;
                ep = lookupino(node.ino);
                if (feof(mf))
                        break;
                ep = lookupino(node.ino);
-               if (ep == NIL) {
-                       if (command != 'r' && command != 'R')
+               if (command == 'i' || command == 'x') {
+                       if (ep == NIL)
+                               continue;
+                       if (ep->e_flags & EXISTED) {
+                               ep->e_flags &= ~NEW;
+                               continue;
+                       }
+                       if (node.ino == ROOTINO &&
+                           reply("set owner/mode for '.'") == FAIL)
                                continue;
                                continue;
+               }
+               if (ep == NIL) {
                        panic("cannot find directory inode %d\n", node.ino);
                        panic("cannot find directory inode %d\n", node.ino);
+               } else {
+                       cp = myname(ep);
+                       (void) chown(cp, node.uid, node.gid);
+                       (void) chmod(cp, node.mode);
+                       utimes(cp, node.timep);
+                       ep->e_flags &= ~NEW;
                }
                }
-               cp = myname(ep);
-               (void) chown(cp, node.uid, node.gid);
-               (void) chmod(cp, node.mode);
-               utime(cp, node.timep);
-               ep->e_flags &= ~NEW;
        }
        if (ferror(mf))
                panic("error setting directory modes\n");
        }
        if (ferror(mf))
                panic("error setting directory modes\n");
@@ -479,11 +582,13 @@ genliteraldir(name, ino)
        itp = inotablookup(ino);
        if (itp == NULL)
                panic("Cannot find directory inode %d named %s\n", ino, name);
        itp = inotablookup(ino);
        if (itp == NULL)
                panic("Cannot find directory inode %d named %s\n", ino, name);
-       if ((ofile = open(name, FWRONLY|FCREATE, 0666)) < 0) {
-               fprintf(stderr, "%s: cannot create file\n", name);
+       if ((ofile = creat(name, 0666)) < 0) {
+               fprintf(stderr, "%s: ", name);
+               (void) fflush(stderr);
+               perror("cannot create file");
                return (FAIL);
        }
                return (FAIL);
        }
-       seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
+       rst_seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
        dp = dup(dirp->dd_fd);
        for (i = itp->t_size; i > 0; i -= BUFSIZ) {
                size = i < BUFSIZ ? i : BUFSIZ;
        dp = dup(dirp->dd_fd);
        for (i = itp->t_size; i > 0; i -= BUFSIZ) {
                size = i < BUFSIZ ? i : BUFSIZ;
@@ -494,7 +599,7 @@ genliteraldir(name, ino)
                        perror("read");
                        done(1);
                }
                        perror("read");
                        done(1);
                }
-               if (write(ofile, buf, (int) size) == -1) {
+               if (!Nflag && write(ofile, buf, (int) size) == -1) {
                        fprintf(stderr,
                                "write error extracting inode %d, name %s\n",
                                curfile.ino, curfile.name);
                        fprintf(stderr,
                                "write error extracting inode %d, name %s\n",
                                curfile.ino, curfile.name);
@@ -507,171 +612,6 @@ genliteraldir(name, ino)
        return (GOOD);
 }
 
        return (GOOD);
 }
 
-/*
- * Do an "ls" style listing of a directory
- */
-printlist(name, ino)
-       char *name;
-       ino_t ino;
-{
-       register struct afile *fp;
-       register struct inotab *itp;
-       struct afile *dfp0, *dfplast;
-       struct afile single;
-
-       itp = inotablookup(ino);
-       if (itp == NULL) {
-               single.fnum = ino;
-               single.fname = savename(rindex(name, '/') + 1);
-               dfp0 = &single;
-               dfplast = dfp0 + 1;
-       } else {
-               seekdir(dirp, itp->t_seekpt, itp->t_seekpt);
-               if (getdir(dirp, &dfp0, &dfplast) == FAIL)
-                       return;
-       }
-       qsort((char *)dfp0, dfplast - dfp0, sizeof (struct afile), fcmp);
-       formatf(dfp0, dfplast);
-       for (fp = dfp0; fp < dfplast; fp++)
-               freename(fp->fname);
-}
-
-/*
- * Read the contents of a directory.
- */
-getdir(dirp, pfp0, pfplast)
-       DIR *dirp;
-       struct afile **pfp0, **pfplast;
-{
-       register struct afile *fp;
-       register struct direct *dp;
-       static struct afile *basefp = NULL;
-       static long nent = 20;
-
-       if (basefp == NULL)
-               basefp = (struct afile *)calloc((unsigned)nent,
-                       sizeof (struct afile));
-       fp = *pfp0 = basefp;
-       *pfplast = *pfp0 + nent;
-       while (dp = readdir(dirp)) {
-               if (dp == NULL || dp->d_ino == 0)
-                       break;
-               if (!dflag && BIT(dp->d_ino, dumpmap) == 0)
-                       continue;
-               if (vflag == 0 &&
-                   (strcmp(dp->d_name, ".") == 0 ||
-                    strcmp(dp->d_name, "..") == 0))
-                       continue;
-               fp->fnum = dp->d_ino;
-               fp->fname = savename(dp->d_name);
-               fp++;
-               if (fp == *pfplast) {
-                       basefp = (struct afile *)realloc((char *)basefp,
-                           (unsigned)(2 * nent * sizeof (struct afile)));
-                       if (basefp == 0) {
-                               fprintf(stderr, "ls: out of memory\n");
-                               return (FAIL);
-                       }
-                       *pfp0 = basefp;
-                       fp = *pfp0 + nent;
-                       *pfplast = fp + nent;
-                       nent *= 2;
-               }
-       }
-       *pfplast = fp;
-       return (GOOD);
-}
-
-/*
- * Print out a pretty listing of a directory
- */
-formatf(fp0, fplast)
-       struct afile *fp0, *fplast;
-{
-       register struct afile *fp;
-       struct entry *np;
-       int width = 0, w, nentry = fplast - fp0;
-       int i, j, len, columns, lines;
-       char *cp;
-
-       if (fp0 == fplast)
-               return;
-       for (fp = fp0; fp < fplast; fp++) {
-               fp->ftype = inodetype(fp->fnum);
-               np = lookupino(fp->fnum);
-               if (np != NIL)
-                       fp->fflags = np->e_flags;
-               else
-                       fp->fflags = 0;
-               len = strlen(fmtentry(fp));
-               if (len > width)
-                       width = len;
-       }
-       width += 2;
-       columns = 80 / width;
-       if (columns == 0)
-               columns = 1;
-       lines = (nentry + columns - 1) / columns;
-       for (i = 0; i < lines; i++) {
-               for (j = 0; j < columns; j++) {
-                       fp = fp0 + j * lines + i;
-                       cp = fmtentry(fp);
-                       fprintf(stderr, "%s", cp);
-                       if (fp + lines >= fplast) {
-                               fprintf(stderr, "\n");
-                               break;
-                       }
-                       w = strlen(cp);
-                       while (w < width) {
-                               w++;
-                               fprintf(stderr, " ");
-                       }
-               }
-       }
-}
-
-/*
- * Comparison routine for qsort.
- */
-fcmp(f1, f2)
-       register struct afile *f1, *f2;
-{
-
-       return (strcmp(f1->fname, f2->fname));
-}
-
-/*
- * Format a directory entry.
- */
-char *
-fmtentry(fp)
-       register struct afile *fp;
-{
-       static char fmtres[BUFSIZ];
-       register char *cp, *dp;
-
-       if (vflag)
-               (void) sprintf(fmtres, "%5d ", fp->fnum);
-       else
-               fmtres[0] = '\0';
-       dp = &fmtres[strlen(fmtres)];
-       if (dflag && BIT(fp->fnum, dumpmap) == 0)
-               *dp++ = '^';
-       else if ((fp->fflags & NEW) != 0)
-               *dp++ = '*';
-       else
-               *dp++ = ' ';
-       for (cp = fp->fname; *cp; cp++)
-               if (!vflag && (*cp < ' ' || *cp >= 0177))
-                       *dp++ = '?';
-               else
-                       *dp++ = *cp;
-       if (fp->ftype == NODE)
-               *dp++ = '/';
-       *dp++ = 0;
-       return (fmtres);
-}
-
 /*
  * Determine the type of an inode
  */
 /*
  * Determine the type of an inode
  */
@@ -700,6 +640,8 @@ allocinotab(ino, dip, seekpt)
        struct modeinfo node;
 
        itp = (struct inotab *)calloc(1, sizeof(struct inotab));
        struct modeinfo node;
 
        itp = (struct inotab *)calloc(1, sizeof(struct inotab));
+       if (itp == 0)
+               panic("no memory directory table\n");
        itp->t_next = inotab[INOHASH(ino)];
        inotab[INOHASH(ino)] = itp;
        itp->t_ino = ino;
        itp->t_next = inotab[INOHASH(ino)];
        inotab[INOHASH(ino)] = itp;
        itp->t_ino = ino;
@@ -707,8 +649,10 @@ allocinotab(ino, dip, seekpt)
        if (mf == NULL)
                return(itp);
        node.ino = ino;
        if (mf == NULL)
                return(itp);
        node.ino = ino;
-       node.timep[0] = dip->di_atime;
-       node.timep[1] = dip->di_mtime;
+       node.timep[0].tv_sec = dip->di_atime;
+       node.timep[0].tv_usec = 0;
+       node.timep[1].tv_sec = dip->di_mtime;
+       node.timep[1].tv_usec = 0;
        node.mode = dip->di_mode;
        node.uid = dip->di_uid;
        node.gid = dip->di_gid;
        node.mode = dip->di_mode;
        node.uid = dip->di_uid;
        node.gid = dip->di_gid;