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 bd6f1d6..ee5d095 100644 (file)
--- a/usr/src/sbin/fsck/dir.c
+++ b/usr/src/sbin/fsck/dir.c
@@ -1,36 +1,60 @@
 /*
 /*

- * 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.

  *
  *

- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * 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.13 (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"
 
 char   *lfname = "lost+found";
 int    lfmode = 01777;
 struct dirtemplate emptydir = { 0, DIRBLKSIZ };
 #include "fsck.h"
 
 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();


@@ -85,12 +109,33 @@ dirscan(idesc)
        idesc->id_loc = 0;
        for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
                dsize = dp->d_reclen;
        idesc->id_loc = 0;
        for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) {
                dsize = dp->d_reclen;

-               bcopy((char *)dp, dbuf, dsize);
+               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,
                        bp = getdirblk(idesc->id_blkno, blksiz);
                        bcopy(dbuf, bp->b_un.b_buf + idesc->id_loc - dsize,

-                           dsize);
+                           (size_t)dsize);

                        dirty(bp);
                        sbdirty();
                }
                        dirty(bp);
                        sbdirty();
                }


@@ -109,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);


@@ -118,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)


@@ -147,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);


@@ -165,21 +212,35 @@ 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++)
-                       if (*cp == 0 || (*cp++ & 0200))
+               for (cp = dp->d_name, size = 0; size < namlen; size++)
+                       if (*cp == 0 || (*cp++ == '/'))

                                return (0);
                if (*cp == 0)
                        return (1);
                                return (0);
                if (*cp == 0)
                        return (1);


@@ -256,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)


@@ -267,9 +328,13 @@ 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;
        dirp->d_reclen = newent.d_reclen;
        dirp->d_namlen = newent.d_namlen;

-       bcopy(idesc->id_name, dirp->d_name, (int)dirp->d_namlen + 1);
+       bcopy(idesc->id_name, dirp->d_name, (size_t)dirp->d_namlen + 1);

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


@@ -281,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);
 }
 


@@ -374,14 +443,14 @@ linkup(orphan, parentdir)
        if (lostdir) {
                if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 &&
                    parentdir != (ino_t)-1)
        if (lostdir) {
                if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 &&
                    parentdir != (ino_t)-1)

-                       makeentry(orphan, lfdir, "..");
+                       (void)makeentry(orphan, lfdir, "..");

                dp = ginode(lfdir);
                dp->di_nlink++;
                inodirty();
                lncntp[lfdir]++;
                dp = ginode(lfdir);
                dp->di_nlink++;
                inodirty();
                lncntp[lfdir]++;

-               pwarn("DIR I=%u CONNECTED. ", orphan);
+               pwarn("DIR I=%lu CONNECTED. ", orphan);

                if (parentdir != (ino_t)-1)
                if (parentdir != (ino_t)-1)

-                       printf("PARENT WAS I=%u\n", parentdir);
+                       printf("PARENT WAS I=%lu\n", parentdir);

                if (preen == 0)
                        printf("\n");
        }
                if (preen == 0)
                        printf("\n");
        }


@@ -455,7 +524,7 @@ expanddir(dp, name)
        char *cp, firstblk[DIRBLKSIZ];
 
        lastbn = lblkno(&sblock, dp->di_size);
        char *cp, firstblk[DIRBLKSIZ];
 
        lastbn = lblkno(&sblock, dp->di_size);

-       if (lastbn >= NDADDR - 1)
+       if (lastbn >= NDADDR - 1 || dp->di_db[lastbn] == 0 || dp->di_size == 0)

                return (0);
        if ((newblk = allocblk(sblock.fs_frag)) == 0)
                return (0);
                return (0);
        if ((newblk = allocblk(sblock.fs_frag)) == 0)
                return (0);


@@ -464,7 +533,7 @@ expanddir(dp, name)
        dp->di_size += sblock.fs_bsize;
        dp->di_blocks += btodb(sblock.fs_bsize);
        bp = getdirblk(dp->di_db[lastbn + 1],
        dp->di_size += sblock.fs_bsize;
        dp->di_blocks += btodb(sblock.fs_bsize);
        bp = getdirblk(dp->di_db[lastbn + 1],

-               dblksize(&sblock, dp, lastbn + 1));
+               (long)dblksize(&sblock, dp, lastbn + 1));

        if (bp->b_errs)
                goto bad;
        bcopy(bp->b_un.b_buf, firstblk, DIRBLKSIZ);
        if (bp->b_errs)
                goto bad;
        bcopy(bp->b_un.b_buf, firstblk, DIRBLKSIZ);


@@ -478,7 +547,7 @@ expanddir(dp, name)
                bcopy((char *)&emptydir, cp, sizeof emptydir);
        dirty(bp);
        bp = getdirblk(dp->di_db[lastbn + 1],
                bcopy((char *)&emptydir, cp, sizeof emptydir);
        dirty(bp);
        bp = getdirblk(dp->di_db[lastbn + 1],

-               dblksize(&sblock, dp, lastbn + 1));
+               (long)dblksize(&sblock, dp, lastbn + 1));

        if (bp->b_errs)
                goto bad;
        bcopy((char *)&emptydir, bp->b_un.b_buf, sizeof emptydir);
        if (bp->b_errs)
                goto bad;
        bcopy((char *)&emptydir, bp->b_un.b_buf, sizeof emptydir);


@@ -510,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)


@@ -530,12 +604,14 @@ allocdir(parent, request, mode)
        inodirty();
        if (ino == ROOTINO) {
                lncntp[ino] = dp->di_nlink;
        inodirty();
        if (ino == ROOTINO) {
                lncntp[ino] = dp->di_nlink;

+               cacheino(dp, ino);

                return(ino);
        }
        if (statemap[parent] != DSTATE && statemap[parent] != DFOUND) {
                freeino(ino);
                return (0);
        }
                return(ino);
        }
        if (statemap[parent] != DSTATE && statemap[parent] != DFOUND) {
                freeino(ino);
                return (0);
        }

+       cacheino(dp, ino);

        statemap[ino] = statemap[parent];
        if (statemap[ino] == DSTATE) {
                lncntp[ino] = dp->di_nlink;
        statemap[ino] = statemap[parent];
        if (statemap[ino] == DSTATE) {
                lncntp[ino] = dp->di_nlink;


@@ -597,10 +673,9 @@ getdirblk(blkno, size)
        daddr_t blkno;
        long size;
 {
        daddr_t blkno;
        long size;
 {

-       static struct bufarea *pbp = 0;

 
 

-       if (pbp != 0)
-               pbp->b_flags &= ~B_INUSE;
-       pbp = getdatablk(blkno, size);
-       return (pbp);
+       if (pdirbp != 0)
+               pdirbp->b_flags &= ~B_INUSE;
+       pdirbp = getdatablk(blkno, size);
+       return (pdirbp);

 }
 }