Return to inode.c CVS log

Up to [Research Unix] / researchv10no / cmd / worm

Annotation of researchv10no/cmd/worm/inode.c, revision 1.1

1.1     ! root        1: #include       <libc.h>
        !             2: #include       "worm.h"
        !             3: #include       <sys/types.h>
        !             4: #include       <sys/udaioc.h>
        !             5: 
        !             6: Inode *(*inodefn)();
        !             7: void (*traversefn)();
        !             8: extern Inode *vinodefn(), *binodefn();
        !             9: extern void vtraverse(), btraverse();
        !            10: extern char *lkopi(), *cbtinit();
        !            11: long numinodes;
        !            12: long numnamechars;
        !            13: 
        !            14: char *
        !            15: openinode(s, flags)
        !            16:        register Superblock *s;
        !            17: {
        !            18:        short fd = s->fd;
        !            19:        char *b, *z;
        !            20:        long blk;
        !            21:        unsigned short ibuf[3];
        !            22:        static char buf[64];
        !            23:        extern char *getenv();
        !            24:        extern long atol();
        !            25: int goo; extern errno; int ntry;
        !            26: 
        !            27:        if(z = getenv("WORMZERO"))
        !            28:                blk = atol(z);
        !            29:        else
        !            30:                blk = 0;
        !            31:        ntry = 0;
        !            32: loop:
        !            33:        bigseek(s->fd, blk, 1024, 0);
        !            34:        if(((goo = read(s->fd, (char *)ibuf, sizeof ibuf)) != sizeof ibuf) ||
        !            35:                        ((((long)ibuf[1])<<16|ibuf[0]) != SMAGIC)){
        !            36:                if((goo < 0) && (errno == ENXIO))
        !            37:                        blk++;  /* blank check (unwritten), try next blk */
        !            38:                else if((goo == sizeof ibuf) && (ibuf[0] == 0) && (ibuf[1] == 0))
        !            39:                        blk++;  /* zeroes(??), try next blk */
        !            40:                else {
        !            41:                        fprint(2, "DEBUGGING[%d]: read=%d magic=0x%lx errno=%d\n",
        !            42:                                ntry, goo, (((long)ibuf[1])<<16|ibuf[0]), errno);
        !            43:                        if(ntry++ < 3)
        !            44:                                goto loop;
        !            45:                }
        !            46:                bigseek(s->fd, blk, 1024, 0);
        !            47:                if(read(s->fd, (char *)ibuf, sizeof ibuf) < sizeof ibuf)
        !            48:                        return("no block size");
        !            49:        }
        !            50:        if(flags&SPIN_DOWN)
        !            51:                ioctl(s->fd, UIOSPDW);
        !            52:        s->blocksize = ibuf[2];         /* magic is 0-1 */
        !            53:        if((b = malloc(s->blocksize)) == 0){
        !            54:                sprint(buf, "couldn't malloc buffer (%d bytes)", s->blocksize);
        !            55:                return(buf);
        !            56:        }
        !            57:        bigseek(s->fd, blk, 1024, 0);
        !            58:        if(read(s->fd, b, s->blocksize) != s->blocksize)
        !            59:                return("superblock read error");
        !            60:        *s = *((Superblock *)b);
        !            61:        free(b);
        !            62:        s->fd = fd;
        !            63:        if(s->myblock == 0)
        !            64:                s->myblock = blk;
        !            65:        switch(s->version)
        !            66:        {
        !            67:        case VLINK:
        !            68:                if(flags&DO_INODE){
        !            69:                        Superblock tmpsb;
        !            70: 
        !            71:                        tmpsb = *s;
        !            72:                        if(b = lkopi(s, blk, 0))
        !            73:                                return(b);
        !            74:                        if(fastlink(s, &b, &inodefn, &traversefn))
        !            75:                                return(b);
        !            76:                        *s = tmpsb;
        !            77:                }
        !            78:                inodefn = vinodefn;
        !            79:                traversefn = vtraverse;
        !            80:                return(lkopi(s, blk, flags&DO_INODE));
        !            81:        case VBTREE:
        !            82:                inodefn = binodefn;
        !            83:                traversefn = btraverse;
        !            84:                return(cbtinit(s, blk, flags&DO_INODE));
        !            85:        default:
        !            86:                sprint(buf, "unknown version %d@%ld", s->version, blk);
        !            87:                return(buf);
        !            88:        }
        !            89: }

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