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

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.