add firewall check for bad entry in state map

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

/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved.  The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/

#ifndef lint
static char sccsid[] = "@(#)pass4.c     5.3 (Berkeley) %G%";
#endif not lint

#include <sys/param.h>
#include <sys/inode.h>
#include <sys/fs.h>
#include "fsck.h"

int     pass4check();

pass4()
{
       register ino_t inumber;
       register struct zlncnt *zlnp;
       struct inodesc idesc;
       int n;

       bzero((char *)&idesc, sizeof(struct inodesc));
       idesc.id_type = ADDR;
       idesc.id_func = pass4check;
       for (inumber = ROOTINO; inumber <= lastino; inumber++) {
               idesc.id_number = inumber;
               switch (statemap[inumber]) {

               case FSTATE:
               case DFOUND:
                       n = lncntp[inumber];
                       if (n)
                               adjust(&idesc, (short)n);
                       else {
                               for (zlnp = zlnhead; zlnp; zlnp = zlnp->next)
                                       if (zlnp->zlncnt == inumber) {
                                               zlnp->zlncnt = zlnhead->zlncnt;
                                               zlnp = zlnhead;
                                               zlnhead = zlnhead->next;
                                               free(zlnp);
                                               clri(&idesc, "UNREF", 1);
                                               break;
                                       }
                       }
                       break;

               case DSTATE:
                       clri(&idesc, "UNREF", 1);
                       break;

               case DCLEAR:
               case FCLEAR:
                       clri(&idesc, "BAD/DUP", 1);
                       break;

               case USTATE:
                       break;

               default:
                       errexit("BAD STATE %d FOR INODE I=%d",
                           statemap[inumber], inumber);
               }
       }
}

pass4check(idesc)
       register struct inodesc *idesc;
{
       register struct dups *dlp;
       int nfrags, res = KEEPON;
       daddr_t blkno = idesc->id_blkno;

       for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
               if (outrange(blkno, 1)) {
                       res = SKIP;
               } else if (getbmap(blkno)) {
                       for (dlp = duplist; dlp; dlp = dlp->next) {
                               if (dlp->dup != blkno)
                                       continue;
                               dlp->dup = duplist->dup;
                               dlp = duplist;
                               duplist = duplist->next;
                               free(dlp);
                               break;
                       }
                       if (dlp == 0) {
                               clrbmap(blkno);
                               n_blks--;
                       }
               }
       }
       return (res);
}