Return to hideblock.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/hideblock.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * hideblock filesystem(not raw) file b1 b2 ...
        !             3:  *  -- puts blocks in named file in file system.
        !             4:  */
        !             5: 
        !             6: #include <stdio.h>
        !             7: #include <sys/param.h>
        !             8: #include <sys/ino.h>
        !             9: #include <sys/stat.h>
        !            10: 
        !            11: #ifdef BITFS
        !            12: #define        Bsize   BSIZE(dev)
        !            13: #define        Inopb   INOPB(dev)
        !            14: #else
        !            15: #define        Bsize   BSIZE
        !            16: #define        Inopb   INOPB
        !            17: #endif
        !            18: 
        !            19: int    fd;
        !            20: struct dinode di;
        !            21: ino_t  inode;
        !            22: char   cntflag;
        !            23: long   count;
        !            24: long   size;
        !            25: dev_t  dev;
        !            26: int    writing;
        !            27: 
        !            28: main(argc,argv)
        !            29: char **argv;
        !            30: {
        !            31:        long pos;
        !            32:        int i,j;
        !            33:        long addr[13];
        !            34:        char *file;
        !            35:        struct stat s;
        !            36: 
        !            37:        if(argc<3) {
        !            38:                printf("usage: %s non-raw-fs file b1 b2 ... (512)\n", argv[0]);
        !            39:                exit(1);
        !            40:        }
        !            41:        writing = argc>3;
        !            42:        if ((fd=open(argv[1], writing?2:0)) < 0) {
        !            43:                perror(argv[1]);
        !            44:                printf("%s couldn't open %s\n", argv[0], argv[1]);
        !            45:                exit(1);
        !            46:        }
        !            47:        if (stat(argv[2], &s) < 0) {
        !            48:                printf("%s: %s must exist\n", argv[0], argv[2]);
        !            49:                exit(1);
        !            50:        }
        !            51:        if (s.st_size != 0 && argc>3) {
        !            52:                printf("%s: %s must be 0 length\n", argv[0], argv[2]);
        !            53:                exit(1);
        !            54:        }
        !            55:        inode = s.st_ino;
        !            56:        dev = s.st_dev;
        !            57:        pos = ((long)inode-1)/Inopb*Bsize+((inode-1)%Inopb)*sizeof(struct dinode);
        !            58:        pos += 2*Bsize;
        !            59:        lseek(fd, pos, 0);
        !            60:        bread(fd, &di, sizeof(di));
        !            61:        l3tol(addr, di.di_addr, 13);
        !            62:        for (i = 0; i < 10; i++) {
        !            63:                if (addr[i])
        !            64:                        printf(" %ld", addr[i]*(Bsize/512));
        !            65:                else
        !            66:                        break;
        !            67:        }
        !            68:        argc -= 2;
        !            69:        argv += 2;
        !            70:        while (argc > 1) {
        !            71:                if (i >= 10) {
        !            72:                        printf("\nhideblock: at most 10 blocks\n");
        !            73:                        break;
        !            74:                }
        !            75:                addr[i] = atol(argv[1])/(Bsize/512);
        !            76:                printf(" %ld", addr[i]*(Bsize/512));
        !            77:                i++;
        !            78:                argc--;
        !            79:                argv++;
        !            80:        }
        !            81:        printf("\n");
        !            82:        if (writing) {
        !            83:                ltol3(di.di_addr, addr, 13);
        !            84:                lseek(fd, pos, 0);
        !            85:                bwrite(fd, &di, sizeof(di));
        !            86:        }
        !            87:        return(0);
        !            88: }
        !            89: 
        !            90: bread(f, b, c)
        !            91: char *b;
        !            92: {
        !            93:        register n;
        !            94: 
        !            95:        n = read(f, b, c);
        !            96:        if (n!=c)
        !            97:                printf("bad read on %d: %d\n", f, n);
        !            98: }
        !            99: 
        !           100: bwrite(f, b, c)
        !           101: char *b;
        !           102: {
        !           103:        register n;
        !           104: 
        !           105:        n = write(f, b, c);
        !           106:        if (n!=c)
        !           107:                printf("bad write on %d: %d\n", f, n);
        !           108: }

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