BSD 4_4 release

[unix-history] / usr / src / sbin / fsck / dir.c

diff --git a/usr/src/sbin/fsck/dir.c b/usr/src/sbin/fsck/dir.c
index 6d7f1fd..ee5d095 100644 (file)
--- a/usr/src/sbin/fsck/dir.c
+++ b/usr/src/sbin/fsck/dir.c
@@ -1,20 +1,45 @@
 /*
 /*

- * Copyright (c) 1980, 1986 The Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1980, 1986, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  *

- * %sccs.include.redist.c%
+ * 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[] = "@(#)dir.c      5.19 (Berkeley) %G%";
+static char sccsid[] = "@(#)dir.c      8.1 (Berkeley) 6/5/93";

 #endif /* not lint */
 
 #include <sys/param.h>
 #endif /* not lint */
 
 #include <sys/param.h>

-#include <ufs/dinode.h>
-#include <ufs/fs.h>
-#define KERNEL
-#include <ufs/dir.h>
-#undef KERNEL
+#include <sys/time.h>
+#include <ufs/ufs/dinode.h>
+#include <ufs/ufs/dir.h>
+#include <ufs/ffs/fs.h>

 #include <stdlib.h>
 #include <string.h>
 #include "fsck.h"
 #include <stdlib.h>
 #include <string.h>
 #include "fsck.h"


@@ -22,7 +47,14 @@ static char sccsid[] = "@(#)dir.c    5.19 (Berkeley) %G%";
 char   *lfname = "lost+found";
 int    lfmode = 01777;
 struct dirtemplate emptydir = { 0, DIRBLKSIZ };
 char   *lfname = "lost+found";
 int    lfmode = 01777;
 struct dirtemplate emptydir = { 0, DIRBLKSIZ };

-struct dirtemplate dirhead = { 0, 12, 1, ".", 0, DIRBLKSIZ - 12, 2, ".." };
+struct dirtemplate dirhead = {
+       0, 12, DT_DIR, 1, ".",
+       0, DIRBLKSIZ - 12, DT_DIR, 2, ".."
+};
+struct odirtemplate odirhead = {
+       0, 12, 1, ".",
+       0, DIRBLKSIZ - 12, 2, ".."
+};

 
 struct direct  *fsck_readdir();
 struct bufarea *getdirblk();
 
 struct direct  *fsck_readdir();
 struct bufarea *getdirblk();


@@ -78,8 +110,29 @@ dirscan(idesc)
        for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
                dsize = dp->d_reclen;
                bcopy((char *)dp, dbuf, (size_t)dsize);
        for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
                dsize = dp->d_reclen;
                bcopy((char *)dp, dbuf, (size_t)dsize);

+#              if (BYTE_ORDER == LITTLE_ENDIAN)
+                       if (!newinofmt) {
+                               struct direct *tdp = (struct direct *)dbuf;
+                               u_char tmp;
+
+                               tmp = tdp->d_namlen;
+                               tdp->d_namlen = tdp->d_type;
+                               tdp->d_type = tmp;
+                       }
+#              endif

                idesc->id_dirp = (struct direct *)dbuf;
                if ((n = (*idesc->id_func)(idesc)) & ALTERED) {
                idesc->id_dirp = (struct direct *)dbuf;
                if ((n = (*idesc->id_func)(idesc)) & ALTERED) {

+#                      if (BYTE_ORDER == LITTLE_ENDIAN)
+                               if (!newinofmt && !doinglevel2) {
+                                       struct direct *tdp;
+                                       u_char tmp;
+
+                                       tdp = (struct direct *)dbuf;
+                                       tmp = tdp->d_namlen;
+                                       tdp->d_namlen = tdp->d_type;
+                                       tdp->d_type = tmp;
+                               }
+#                      endif

                        bp = getdirblk(idesc->id_blkno, blksiz);
                        bcopy(dbuf, bp->b_un.b_buf + idesc->id_loc - dsize,
                            (size_t)dsize);
                        bp = getdirblk(idesc->id_blkno, blksiz);
                        bcopy(dbuf, bp->b_un.b_buf + idesc->id_loc - dsize,
                            (size_t)dsize);


@@ -101,7 +154,7 @@ fsck_readdir(idesc)
 {
        register struct direct *dp, *ndp;
        register struct bufarea *bp;
 {
        register struct direct *dp, *ndp;
        register struct bufarea *bp;

-       long size, blksiz, fix;
+       long size, blksiz, fix, dploc;

 
        blksiz = idesc->id_numfrags * sblock.fs_fsize;
        bp = getdirblk(idesc->id_blkno, blksiz);
 
        blksiz = idesc->id_numfrags * sblock.fs_fsize;
        bp = getdirblk(idesc->id_blkno, blksiz);


@@ -110,23 +163,25 @@ fsck_readdir(idesc)
                dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
                if (dircheck(idesc, dp))
                        goto dpok;
                dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
                if (dircheck(idesc, dp))
                        goto dpok;

-               idesc->id_loc += DIRBLKSIZ;
-               idesc->id_filesize -= DIRBLKSIZ;

                fix = dofix(idesc, "DIRECTORY CORRUPTED");
                bp = getdirblk(idesc->id_blkno, blksiz);
                dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
                dp->d_reclen = DIRBLKSIZ;
                dp->d_ino = 0;
                fix = dofix(idesc, "DIRECTORY CORRUPTED");
                bp = getdirblk(idesc->id_blkno, blksiz);
                dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
                dp->d_reclen = DIRBLKSIZ;
                dp->d_ino = 0;

+               dp->d_type = 0;

                dp->d_namlen = 0;
                dp->d_name[0] = '\0';
                if (fix)
                        dirty(bp);
                dp->d_namlen = 0;
                dp->d_name[0] = '\0';
                if (fix)
                        dirty(bp);

+               idesc->id_loc += DIRBLKSIZ;
+               idesc->id_filesize -= DIRBLKSIZ;

                return (dp);
        }
 dpok:
        if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
                return NULL;
                return (dp);
        }
 dpok:
        if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz)
                return NULL;

-       dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
+       dploc = idesc->id_loc;
+       dp = (struct direct *)(bp->b_un.b_buf + dploc);

        idesc->id_loc += dp->d_reclen;
        idesc->id_filesize -= dp->d_reclen;
        if ((idesc->id_loc % DIRBLKSIZ) == 0)
        idesc->id_loc += dp->d_reclen;
        idesc->id_filesize -= dp->d_reclen;
        if ((idesc->id_loc % DIRBLKSIZ) == 0)


@@ -139,7 +194,7 @@ dpok:
                idesc->id_filesize -= size;
                fix = dofix(idesc, "DIRECTORY CORRUPTED");
                bp = getdirblk(idesc->id_blkno, blksiz);
                idesc->id_filesize -= size;
                fix = dofix(idesc, "DIRECTORY CORRUPTED");
                bp = getdirblk(idesc->id_blkno, blksiz);

-               dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc);
+               dp = (struct direct *)(bp->b_un.b_buf + dploc);

                dp->d_reclen += size;
                if (fix)
                        dirty(bp);
                dp->d_reclen += size;
                if (fix)
                        dirty(bp);


@@ -157,20 +212,34 @@ dircheck(idesc, dp)
 {
        register int size;
        register char *cp;
 {
        register int size;
        register char *cp;

+       u_char namlen, type;

        int spaceleft;
 
        int spaceleft;
 

-       size = DIRSIZ(dp);
+       size = DIRSIZ(!newinofmt, dp);

        spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);
        spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ);

+#      if (BYTE_ORDER == LITTLE_ENDIAN)
+               if (!newinofmt) {
+                       type = dp->d_namlen;
+                       namlen = dp->d_type;
+               } else {
+                       namlen = dp->d_namlen;
+                       type = dp->d_type;
+               }
+#      else
+               namlen = dp->d_namlen;
+               type = dp->d_type;
+#      endif

        if (dp->d_ino < maxino &&
            dp->d_reclen != 0 &&
            dp->d_reclen <= spaceleft &&
            (dp->d_reclen & 0x3) == 0 &&
            dp->d_reclen >= size &&
            idesc->id_filesize >= size &&
        if (dp->d_ino < maxino &&
            dp->d_reclen != 0 &&
            dp->d_reclen <= spaceleft &&
            (dp->d_reclen & 0x3) == 0 &&
            dp->d_reclen >= size &&
            idesc->id_filesize >= size &&

-           dp->d_namlen <= MAXNAMLEN) {
+           namlen <= MAXNAMLEN &&
+           type <= 15) {

                if (dp->d_ino == 0)
                        return (1);
                if (dp->d_ino == 0)
                        return (1);

-               for (cp = dp->d_name, size = 0; size < dp->d_namlen; size++)
+               for (cp = dp->d_name, size = 0; size < namlen; size++)

                        if (*cp == 0 || (*cp++ == '/'))
                                return (0);
                if (*cp == 0)
                        if (*cp == 0 || (*cp++ == '/'))
                                return (0);
                if (*cp == 0)


@@ -248,9 +317,9 @@ mkentry(idesc)
        int newlen, oldlen;
 
        newent.d_namlen = strlen(idesc->id_name);
        int newlen, oldlen;
 
        newent.d_namlen = strlen(idesc->id_name);

-       newlen = DIRSIZ(&newent);
+       newlen = DIRSIZ(0, &newent);

        if (dirp->d_ino != 0)
        if (dirp->d_ino != 0)

-               oldlen = DIRSIZ(dirp);
+               oldlen = DIRSIZ(0, dirp);

        else
                oldlen = 0;
        if (dirp->d_reclen - oldlen < newlen)
        else
                oldlen = 0;
        if (dirp->d_reclen - oldlen < newlen)


@@ -259,6 +328,10 @@ mkentry(idesc)
        dirp->d_reclen = oldlen;
        dirp = (struct direct *)(((char *)dirp) + oldlen);
        dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */
        dirp->d_reclen = oldlen;
        dirp = (struct direct *)(((char *)dirp) + oldlen);
        dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */

+       if (newinofmt)
+               dirp->d_type = typemap[idesc->id_parent];
+       else
+               dirp->d_type = 0;

        dirp->d_reclen = newent.d_reclen;
        dirp->d_namlen = newent.d_namlen;
        bcopy(idesc->id_name, dirp->d_name, (size_t)dirp->d_namlen + 1);
        dirp->d_reclen = newent.d_reclen;
        dirp->d_namlen = newent.d_namlen;
        bcopy(idesc->id_name, dirp->d_name, (size_t)dirp->d_namlen + 1);


@@ -273,6 +346,10 @@ chgino(idesc)
        if (bcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
                return (KEEPON);
        dirp->d_ino = idesc->id_parent;
        if (bcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1))
                return (KEEPON);
        dirp->d_ino = idesc->id_parent;

+       if (newinofmt)
+               dirp->d_type = typemap[idesc->id_parent];
+       else
+               dirp->d_type = 0;

        return (ALTERED|STOP);
 }
 
        return (ALTERED|STOP);
 }
 


@@ -502,17 +579,22 @@ allocdir(parent, request, mode)
        char *cp;
        struct dinode *dp;
        register struct bufarea *bp;
        char *cp;
        struct dinode *dp;
        register struct bufarea *bp;

+       struct dirtemplate *dirp;

 
        ino = allocino(request, IFDIR|mode);
 
        ino = allocino(request, IFDIR|mode);

-       dirhead.dot_ino = ino;
-       dirhead.dotdot_ino = parent;
+       if (newinofmt)
+               dirp = &dirhead;
+       else
+               dirp = (struct dirtemplate *)&odirhead;
+       dirp->dot_ino = ino;
+       dirp->dotdot_ino = parent;

        dp = ginode(ino);
        bp = getdirblk(dp->di_db[0], sblock.fs_fsize);
        if (bp->b_errs) {
                freeino(ino);
                return (0);
        }
        dp = ginode(ino);
        bp = getdirblk(dp->di_db[0], sblock.fs_fsize);
        if (bp->b_errs) {
                freeino(ino);
                return (0);
        }

-       bcopy((char *)&dirhead, bp->b_un.b_buf, sizeof dirhead);
+       bcopy((char *)dirp, bp->b_un.b_buf, sizeof(struct dirtemplate));

        for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
             cp < &bp->b_un.b_buf[sblock.fs_fsize];
             cp += DIRBLKSIZ)
        for (cp = &bp->b_un.b_buf[DIRBLKSIZ];
             cp < &bp->b_un.b_buf[sblock.fs_fsize];
             cp += DIRBLKSIZ)