Return to tape.c CVS log

Up to [Research Unix] / researchv10no / cmd

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

1.1     ! root        1: #include "stdio.h"
        !             2: #include "errno.h"
        !             3: #include "signal.h"
        !             4: 
        !             5: extern int     errno;
        !             6: char *tapes[] = {
        !             7:        "/dev/rmt2",
        !             8:        "/dev/rmt1",
        !             9:        "/dev/rmt0",
        !            10:        0
        !            11: };
        !            12: long recnum, reccnt;
        !            13: int broken();
        !            14: long filenum;
        !            15: int eof;
        !            16: unsigned recsz;
        !            17: char buf[60*1024];
        !            18: int fd;
        !            19: 
        !            20: timeout()
        !            21: {
        !            22:        gprintf(stdout, "timeout\n");
        !            23: }
        !            24: 
        !            25: dens()
        !            26: {      int fd, i, n;
        !            27:        for(i = 0; tapes[i]; i++) {
        !            28:                close(fd);
        !            29:                errno = 0;
        !            30:                alarm(60);
        !            31:                fd = open(tapes[i], 0);
        !            32:                alarm(0);
        !            33:                if(fd < 0) {
        !            34:                        perror(tapes[i]);
        !            35:                        continue;
        !            36:                }
        !            37:                alarm(60);
        !            38:                n = read(fd, buf, sizeof(buf));
        !            39:                alarm(0);
        !            40:                if( n >= 0) {
        !            41:                        gprintf(stdout, "%s:\n", tapes[i]);
        !            42:                        close(fd);
        !            43:                        return(i);
        !            44:                }
        !            45:                if(errno == ENXIO) continue;
        !            46:                else perror(tapes[i]);
        !            47:        }
        !            48:        gprintf(stdout, "I can't read anything from your tape\n");
        !            49:        return(-1);
        !            50: }
        !            51: 
        !            52: main()
        !            53: {      int i;
        !            54:        int n;
        !            55:        signal(SIGALRM, timeout);
        !            56:        signal(SIGINT, broken);
        !            57:        i = dens();
        !            58:        if(i == -1) exit(1);
        !            59:        alarm(10);
        !            60:        fd = open(tapes[i], 0);
        !            61:        alarm(0);
        !            62:        if(fd < 0) {
        !            63:                perror("Where did your tape go?");
        !            64:                exit(1);
        !            65:        }
        !            66:        newfile();
        !            67:        for(;;) {
        !            68:                alarm(30);
        !            69:                n = read(fd, buf, sizeof(buf));
        !            70:                alarm(0);
        !            71:                if(n == -1) {
        !            72:                        if(errno == 0) {
        !            73:                                if(reccnt > 0) recdata();
        !            74:                                if(eof == 2) {
        !            75:                                        gprintf(stdout, "2 eofs read\n");
        !            76:                                        exit(0);
        !            77:                                }
        !            78:                                filedata();
        !            79:                                newfile();
        !            80:                        }
        !            81:                        else {
        !            82:                                recdata();
        !            83:                                filedata();
        !            84:                                perror("Bailing out");
        !            85:                                exit(1);
        !            86:                        }
        !            87:                }
        !            88:                else if(n == 0) {
        !            89:                        eof++;
        !            90:                        if(eof == 2) {
        !            91:                                gprintf(stdout, "2 eofs read\n");
        !            92:                                exit(0);
        !            93:                        }
        !            94:                        if(reccnt > 0) recdata();
        !            95:                        filedata();
        !            96:                        newfile();
        !            97:                }
        !            98:                else {
        !            99:                        eof = 0;
        !           100:                        recnum++;
        !           101:                        if(n == recsz) reccnt++;
        !           102:                        else {
        !           103:                                if(reccnt > 0) recdata();
        !           104:                                recsz = n;
        !           105:                                reccnt = 1;
        !           106:                        }
        !           107:                }
        !           108:        }
        !           109: }
        !           110: 
        !           111: newfile()
        !           112: {
        !           113:        filenum++;
        !           114:        recnum = 0;
        !           115:        reccnt = 0;
        !           116:        recsz = 0;
        !           117:        errno = 0;
        !           118: }
        !           119: 
        !           120: filedata()
        !           121: {
        !           122:        gprintf(stdout, "file %ld had %ld records\n", filenum, recnum);
        !           123: }
        !           124: 
        !           125: recdata()
        !           126: {
        !           127:        if(recsz < sizeof(buf))
        !           128:                gprintf(stdout, "file %ld, %ld records of size %u\n", filenum, reccnt, recsz);
        !           129:        else gprintf(stdout, "file %ld, %ld records of size %u (or larger)\n",
        !           130:                filenum, reccnt, recsz);
        !           131: }
        !           132: 
        !           133: broken()
        !           134: {
        !           135:        gprintf(stderr, "interrupted\n");
        !           136:        recdata();
        !           137:        filedata();
        !           138:        exit(0);
        !           139: }
        !           140: 
        !           141: gprintf(s,f,a,b,c,d)
        !           142: FILE *s;
        !           143: char *f;
        !           144: {
        !           145:        fprintf(s,f,a,b,c,d);
        !           146:        fflush(stdout);
        !           147: }

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