Return to crap CVS log

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

Annotation of researchv10no/cmd/worm/crap, revision 1.1

1.1     ! root        1: #include       <libc.h>
        !             2: #include       "sym.h"
        !             3: #include       "worm.h"
        !             4: 
        !             5: main(argc, argv)
        !             6:        char **argv;
        !             7: {
        !             8:        Superblock s;
        !             9:        char *e;
        !            10:        Inode *i;
        !            11:        int c;
        !            12:        char *dev = "/dev/worm0";
        !            13:        extern char *optarg;
        !            14:        extern int optind;
        !            15: 
        !            16:        while((c = getopt(argc, argv, "f:")) != -1)
        !            17:                switch(c)
        !            18:                {
        !            19:                case 'f':       dev = optarg; break;
        !            20:                case '?':       usage();
        !            21:                }
        !            22:        if(optind+2 != argc)
        !            23:                usage();
        !            24:        dev = mapdev(dev);
        !            25:        if((s.fd = open(dev, 0)) < 0){
        !            26:                perror(dev);
        !            27:                exit(1);
        !            28:        }
        !            29:        if(e = openinode(&s, DO_INODE|SPIN_DOWN)){
        !            30:                fprint(2, "%s: %s\n", dev, e);
        !            31:                exit(1);
        !            32:        }
        !            33:        if(strcmp(s.vol_id, argv[optind])){
        !            34:                fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id);
        !            35:                exit(1);
        !            36:        }
        !            37:        if(i = inodeof(argv[++optind]))
        !            38:                c = pr(&s, i);
        !            39:        else {
        !            40:                fprint(2, "wcat: can't find %s\n", argv[optind]);
        !            41:                c = 1;
        !            42:        }
        !            43:        exit(c);
        !            44: }
        !            45: 
        !            46: usage()
        !            47: {
        !            48:        fprint(2, "Usage: worm cat [-fdevice] vol_id file\n");
        !            49:        exit(1);
        !            50: }
        !            51: 
        !            52: pr(s, i)
        !            53:        Superblock *s;
        !            54:        register Inode *i;
        !            55: {
        !            56:        char b[BIGBLOCK];
        !            57:        register long len, n;
        !            58:        long nb;
        !            59:        int fd;
        !            60: 
        !            61:        fd = 1;
        !            62:        nb = sizeof b / s->blocksize;
        !            63:        Seek(s, i->block);
        !            64:        for(n = i->nbytes, len = nb*s->blocksize; n > 0;){
        !            65:                if(len > n){
        !            66:                        len = n;
        !            67:                        nb = (len+s->blocksize-1)/s->blocksize;
        !            68:                }
        !            69:                Read(s, b, nb);
        !            70:                if(write(fd, b, (int)len) != len){
        !            71:                        perror("write");
        !            72:                        return(1);
        !            73:                }
        !            74:                n -= len;
        !            75:        }
        !            76:        close(fd);
        !            77:        return(0);
        !            78: }

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