Return to wpoke.c CVS log

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

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

1.1     ! root        1: #include       <libc.h>
        !             2: #include       "worm.h"
        !             3: 
        !             4: main(argc, argv)
        !             5:        char **argv;
        !             6: {
        !             7:        Superblock s;
        !             8:        char *e, *vol_id = 0;
        !             9:        char *dev = "/dev/worm0";
        !            10:        int c;
        !            11:        long nf = 0;
        !            12:        int vflag = 0;
        !            13:        Superblock ss;
        !            14:        extern char *optarg;
        !            15:        extern int optind;
        !            16:        extern long atol();
        !            17: 
        !            18:        while((c = getopt(argc, argv, "vF:f:")) != -1)
        !            19:                switch(c)
        !            20:                {
        !            21:                case 'f':       dev = optarg; break;
        !            22:                case 'F':       nf = atol(optarg); break;
        !            23:                case 'v':       vflag = 1; break;
        !            24:                case '?':       usage();
        !            25:                }
        !            26:        if(optind < argc){
        !            27:                vol_id = argv[optind++];
        !            28:                if(optind != argc)
        !            29:                        usage();
        !            30:        }
        !            31:        dev = mapdev(dev);
        !            32:        if((s.fd = open(dev, 0)) < 0){
        !            33:                perror(dev);
        !            34:                exit(2);
        !            35:        }
        !            36:        if(read(s.fd, &ss, sizeof ss) != sizeof ss){
        !            37:                if(errno == ENXIO)
        !            38:                        print("unwritten block zero\n");
        !            39:                else
        !            40:                        perror("block zero");
        !            41:        } else {
        !            42:                if(ss.magic == SMAGIC){
        !            43:                        print("appears to be a good superblock at zero\n");
        !            44:                        exit(0);
        !            45:                } else if(ss.magic == 0){
        !            46:                        print("appears to be a zero'ed block at zero.\n");
        !            47:                } else
        !            48:                        print("ignoring bogus block at zero\n");
        !            49:        }
        !            50:        vlink(s.fd, 1);
        !            51:        exit(0);
        !            52: }
        !            53: 
        !            54: usage()
        !            55: {
        !            56:        print("Usage: worm poke [-v] [-fdevice] [-Fnfree] [vol_id]\n");
        !            57:        exit(2);
        !            58: }
        !            59: 
        !            60: vlink(fd, blk)
        !            61: {
        !            62:        Superblock s;
        !            63:        int i, n;
        !            64: 
        !            65:        while(blk < 1650000){
        !            66: loop:
        !            67: print("reading sb at %d\n", blk);
        !            68:                bigseek(fd, blk, 1024, 0);
        !            69:                if(read(fd, &s, sizeof s) == sizeof s){
        !            70:                        if(s.magic == SMAGIC){
        !            71:                                blk = s.nextsb;
        !            72:                                continue;
        !            73:                        }
        !            74:                        print("apparent garbage at supposed superblock@%ld\n", blk);
        !            75:                } else {
        !            76:                        print("bad read at blk %ld, errno=%d\n", blk, errno);
        !            77:                        lseek(fd, 1024, 1);
        !            78:                        blk++;
        !            79:                }
        !            80:                for(i = 0; i < 50; i++){
        !            81:                        n = read(fd, &s, sizeof s);
        !            82:                        if(n < 0){
        !            83:                                lseek(fd, 1024, 1);
        !            84:                                continue;
        !            85:                        }
        !            86:                        if((n == sizeof s) && (s.magic == SMAGIC)){
        !            87:                                blk += i;
        !            88:                                print("after error, skipped %d blocks to apparent superblock at %ld\n", i, blk);
        !            89:                                goto loop;
        !            90:                        }
        !            91:                }
        !            92:                print("after error, no superblock after %d tries\n", i);
        !            93:                blk += i;
        !            94:        }
        !            95: }

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