BSD 4_1c_2 release

[unix-history] / usr / src / etc / ncheck.c

static  char *sccsid = "@(#)ncheck.c    2.2 (Berkeley) 9/10/82";
/*
* ncheck -- obtain file names from reading filesystem
*/

#define NB              500
#define HSIZE           2503
#define MAXNINDIR       (MAXBSIZE / sizeof (daddr_t))

#ifndef SIMFS
#include <sys/param.h>
#include <sys/inode.h>
#include <sys/fs.h>
#else
#include "../h/param.h"
#include "../h/inode.h"
#include "../h/fs.h"
#endif
#include <stdio.h>
#include <dir.h>

struct  fs      sblock;
struct  dinode  itab[MAXIPG];
struct  dinode  *gip;
struct ilist {
       ino_t   ino;
       u_short mode;
       short   uid;
       short   gid;
} ilist[NB];
struct  htab
{
       ino_t   h_ino;
       ino_t   h_pino;
       char    *h_name;
} htab[HSIZE];
char strngtab[30 * HSIZE];
int strngloc;

struct dirstuff {
       int loc;
       struct dinode *ip;
       char dbuf[MAXBSIZE];
};

int     aflg;
int     sflg;
int     iflg; /* number of inodes being searched for */
int     mflg;
int     fi;
ino_t   ino;
int     nhent;
int     nxfile;

int     nerror;
daddr_t bmap();
long    atol();
struct htab *lookup();

main(argc, argv)
       int argc;
       char *argv[];
{
       register i;
       long n;

       while (--argc) {
               argv++;
               if (**argv=='-')
               switch ((*argv)[1]) {

               case 'a':
                       aflg++;
                       continue;

               case 'i':
                       for(iflg=0; iflg<NB; iflg++) {
                               n = atol(argv[1]);
                               if(n == 0)
                                       break;
                               ilist[iflg].ino = n;
                               nxfile = iflg;
                               argv++;
                               argc--;
                       }
                       continue;

               case 'm':
                       mflg++;
                       continue;

               case 's':
                       sflg++;
                       continue;

               default:
                       fprintf(stderr, "ncheck: bad flag %c\n", (*argv)[1]);
                       nerror++;
               }
               check(*argv);
       }
       return(nerror);
}

check(file)
       char *file;
{
       register int i, j, c;
       int nfiles;

       fi = open(file, 0);
       if(fi < 0) {
               fprintf(stderr, "ncheck: cannot open %s\n", file);
               nerror++;
               return;
       }
       nhent = 0;
       printf("%s:\n", file);
       sync();
       bread(SBLOCK, (char *)&sblock, SBSIZE);
       if (sblock.fs_magic != FS_MAGIC) {
               printf("%s: not a file system\n", file);
               nerror++;
               return;
       }
       ino = 0;
       for (c = 0; c < sblock.fs_ncg; c++) {
               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
                   sblock.fs_ipg * sizeof (struct dinode));
               for(j = 0; j < sblock.fs_ipg; j++) {
                       if (itab[j].di_mode != 0)
                               pass1(&itab[j]);
                       ino++;
               }
       }
       ilist[nxfile+1].ino = 0;
       ino = 0;
       for (c = 0; c < sblock.fs_ncg; c++) {
               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
                   sblock.fs_ipg * sizeof (struct dinode));
               for(j = 0; j < sblock.fs_ipg; j++) {
                       if (itab[j].di_mode != 0)
                               pass2(&itab[j]);
                       ino++;
               }
       }
       ino = 0;
       for (c = 0; c < sblock.fs_ncg; c++) {
               bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
                   sblock.fs_ipg * sizeof (struct dinode));
               for(j = 0; j < sblock.fs_ipg; j++) {
                       if (itab[j].di_mode != 0)
                               pass3(&itab[j]);
                       ino++;
               }
       }
       close(fi);
       for (i = 0; i < HSIZE; i++)
               htab[i].h_ino = 0;
       for (i = iflg; i < NB; i++)
               ilist[i].ino = 0;
       nxfile = iflg;
}

pass1(ip)
       register struct dinode *ip;
{
       int i;

       if (mflg)
               for (i = 0; i < iflg; i++)
                       if (ino == ilist[i].ino) {
                               ilist[i].mode = ip->di_mode;
                               ilist[i].uid = ip->di_uid;
                               ilist[i].gid = ip->di_gid;
                       }
       if ((ip->di_mode & IFMT) != IFDIR) {
               if (sflg==0 || nxfile>=NB)
                       return;
               if ((ip->di_mode&IFMT)==IFBLK || (ip->di_mode&IFMT)==IFCHR
                 || ip->di_mode&(ISUID|ISGID)) {
                       ilist[nxfile].ino = ino;
                       ilist[nxfile].mode = ip->di_mode;
                       ilist[nxfile].uid = ip->di_uid;
                       ilist[nxfile++].gid = ip->di_gid;
                       return;
               }
       }
       lookup(ino, 1);
}

pass2(ip)
       register struct dinode *ip;
{
       register struct direct *dp;
       struct dirstuff dirp;
       struct htab *hp;

       if((ip->di_mode&IFMT) != IFDIR)
               return;
       dirp.loc = 0;
       dirp.ip = ip;
       gip = ip;
       for (dp = readdir(&dirp); dp != NULL; dp = readdir(&dirp)) {
               if(dp->d_ino == 0)
                       continue;
               hp = lookup(dp->d_ino, 0);
               if(hp == 0)
                       continue;
               if(dotname(dp))
                       continue;
               hp->h_pino = ino;
               hp->h_name = &strngtab[strngloc];
               strngloc += strlen(dp->d_name) + 1;
               strcpy(hp->h_name, dp->d_name);
       }
}

pass3(ip)
       register struct dinode *ip;
{
       register struct direct *dp;
       struct dirstuff dirp;
       int k;

       if((ip->di_mode&IFMT) != IFDIR)
               return;
       dirp.loc = 0;
       dirp.ip = ip;
       gip = ip;
       for(dp = readdir(&dirp); dp != NULL; dp = readdir(&dirp)) {
               if(aflg==0 && dotname(dp))
                       continue;
               if(sflg == 0 && iflg == 0)
                       goto pr;
               for(k = 0; ilist[k].ino != 0; k++)
                       if(ilist[k].ino == dp->d_ino)
                               break;
               if (ilist[k].ino == 0)
                       continue;
               if (mflg)
                       printf("mode %-6o uid %-5d gid %-5d ino ",
                           ilist[k].mode, ilist[k].uid, ilist[k].gid);
       pr:
               printf("%-5u\t", dp->d_ino);
               pname(ino, 0);
               printf("/%s", dp->d_name);
               if (lookup(dp->d_ino, 0))
                       printf("/.");
               printf("\n");
       }
}

/*
* get next entry in a directory.
*/
struct direct *
readdir(dirp)
       register struct dirstuff *dirp;
{
       register struct direct *dp;
       daddr_t lbn, d;

       for(;;) {
               if (dirp->loc >= dirp->ip->di_size)
                       return NULL;
               if ((lbn = lblkno(&sblock, dirp->loc)) == 0) {
                       d = bmap(lbn);
                       if(d == 0)
                               return NULL;
                       bread(fsbtodb(&sblock, d), dirp->dbuf,
                           dblksize(&sblock, dirp->ip, lbn));
               }
               dp = (struct direct *)
                   (dirp->dbuf + blkoff(&sblock, dirp->loc));
               dirp->loc += dp->d_reclen;
               if (dp->d_ino == 0)
                       continue;
               return (dp);
       }
}

dotname(dp)
       register struct direct *dp;
{

       if (dp->d_name[0]=='.')
               if (dp->d_name[1]==0 ||
                  (dp->d_name[1]=='.' && dp->d_name[2]==0))
                       return(1);
       return(0);
}

pname(i, lev)
       ino_t i;
       int lev;
{
       register struct htab *hp;

       if (i==ROOTINO)
               return;
       if ((hp = lookup(i, 0)) == 0) {
               printf("???");
               return;
       }
       if (lev > 10) {
               printf("...");
               return;
       }
       pname(hp->h_pino, ++lev);
       printf("/%s", hp->h_name);
}

struct htab *
lookup(i, ef)
       ino_t i;
       int ef;
{
       register struct htab *hp;

       for (hp = &htab[i%HSIZE]; hp->h_ino;) {
               if (hp->h_ino==i)
                       return(hp);
               if (++hp >= &htab[HSIZE])
                       hp = htab;
       }
       if (ef==0)
               return(0);
       if (++nhent >= HSIZE) {
               fprintf(stderr, "ncheck: out of core-- increase HSIZE\n");
               exit(1);
       }
       hp->h_ino = i;
       return(hp);
}

bread(bno, buf, cnt)
       daddr_t bno;
       char *buf;
       int cnt;
{
       register i;

       lseek(fi, bno * DEV_BSIZE, 0);
       if (read(fi, buf, cnt) != cnt) {
               fprintf(stderr, "ncheck: read error %d\n", bno);
               for(i=0; i < cnt; i++)
                       buf[i] = 0;
       }
}

daddr_t
bmap(i)
       int i;
{
       daddr_t ibuf[MAXNINDIR];

       if(i < NDADDR)
               return(gip->di_db[i]);
       i -= NDADDR;
       if(i > NINDIR(&sblock)) {
               fprintf(stderr, "ncheck: %u - huge directory\n", ino);
               return((daddr_t)0);
       }
       bread(fsbtodb(&sblock, gip->di_ib[i]), (char *)ibuf, sizeof(ibuf));
       return(ibuf[i]);
}