Return to is_fs.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / misc

Annotation of coherent/g/usr/lib/misc/is_fs.c, revision 1.1

1.1     ! root        1: #include <sys/stat.h>
        !             2: #include <canon.h>
        !             3: #include <sys/filsys.h>
        !             4: 
        !             5: /*
        !             6:  * Check if a special file is a well-formed filesystem.
        !             7:  * This routine is derived from code in "mount.c".
        !             8:  * Return values:
        !             9:  *     -1      Not a device, cannot open, read or seek failed
        !            10:  *     0       No filesystem
        !            11:  *     1       Legal filesystem
        !            12:  */
        !            13: int
        !            14: is_fs(special) char *special;
        !            15: {
        !            16:        static struct filsys f;
        !            17:        struct stat sbuf;
        !            18:        register int fd;
        !            19:        register struct filsys *fp;
        !            20:        register daddr_t *dp;
        !            21:        register ino_t *ip, maxinode;
        !            22: 
        !            23:        if (stat(special, &sbuf) < 0)
        !            24:                return -1;                      /* cannot stat device */
        !            25:        else if ((sbuf.st_mode&S_IFMT) != S_IFBLK
        !            26:              && (sbuf.st_mode&S_IFMT) != S_IFCHR)
        !            27:                return -1;                      /* not a special file */
        !            28:        else if ((fd = open(special, 2)) < 0)
        !            29:                return -1;                      /* cannot open */
        !            30:        else if (lseek(fd, (long)SUPERI*BSIZE, 0) == -1L
        !            31:              || read(fd, &f, sizeof(f)) != sizeof(f)) {
        !            32:                close(fd);
        !            33:                return -1;                      /* seek or read failed */
        !            34:        } else
        !            35:                close(fd);                      /* so far so good */
        !            36: 
        !            37:        /* Canonical stuff. */
        !            38:        fp = &f;
        !            39:        canshort(fp->s_isize);
        !            40:        candaddr(fp->s_fsize);
        !            41:        canshort(fp->s_nfree);
        !            42:        for (dp = &fp->s_free[0]; dp < &fp->s_free[NICFREE]; dp += 1)
        !            43:                candaddr(*dp);
        !            44:        canshort(fp->s_ninode);
        !            45:        for (ip = &fp->s_inode[0]; ip < &fp->s_inode[NICINOD]; ip += 1)
        !            46:                canino(*ip);
        !            47:        candaddr(fp->s_tfree);
        !            48:        canino(fp->s_tinode);
        !            49: 
        !            50:        /* Test for rationality. */
        !            51:        maxinode = (fp->s_isize - INODEI) * INOPB + 1;
        !            52:        if (fp->s_isize >= fp->s_fsize)
        !            53:                return 0;
        !            54:        if ((fp->s_tfree < fp->s_nfree)
        !            55:        ||  (fp->s_tfree >= fp->s_fsize - fp->s_isize + 1))
        !            56:                return 0;
        !            57:        if ((fp->s_tinode < fp->s_ninode) || (fp->s_tinode >= maxinode-1 ))
        !            58:                return 0;
        !            59:        for (dp = &fp->s_free[0]; dp < &fp->s_free[fp->s_nfree]; dp += 1)
        !            60:                if ((*dp < fp->s_isize) || (*dp >= fp->s_fsize))
        !            61:                        return 0;
        !            62:        for (ip = &fp->s_inode[0]; ip < &fp->s_inode[fp->s_ninode]; ip += 1)
        !            63:                if ((*ip < 1) || (*ip > maxinode))
        !            64:                        return 0;
        !            65:        return 1;
        !            66: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.