Return to flcopy.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/flcopy.c, revision 1.1.1.1

1.1       root        1: int floppydes;
                      2: char *flopname = "/dev/floppy";
                      3: 
                      4: main(argc,argv)
                      5: char *argv[];
                      6: {
                      7:        static char buff[512];
                      8:        register count = 77 * 26 * 128, startad = -26 * 128;
                      9:        register int n, file;
                     10: 
                     11:        if(argc==2) {
                     12:                printf("Halftime!\n");
                     13:                if(strcmp(argv[1],"-h")!=0)
                     14:                        printf("Bad halftime option.\n"),
                     15:                        exit(1);
                     16:                if((file = open("floppy",0))<0)
                     17:                        printf("failed to open floppy image"),
                     18:                        exit(1);
                     19:                goto halftime;
                     20:        }
                     21:        file = creat("floppy",0666);
                     22:        close(file);
                     23:        file = open("floppy",2);
                     24:        if(file < 0) exit(1);
                     25:        for( ; count > 0 ; count -= 512) {
                     26:                n = count > 512 ? 512 : count ;
                     27:                lread(startad,n,buff);
                     28:                write(file,buff,n);
                     29:                startad += 512;
                     30:        }
                     31: halftime:
                     32:        printf("Change Floppy, Hit return when done.\n");
                     33:        gets(buff);
                     34:        lseek(file,0,0);
                     35:        count = 77 * 26 * 128; startad = -26 * 128;
                     36:        for( ; count > 0 ; count -= 512) {
                     37:                n = count > 512 ? 512 : count ;
                     38:                read(file,buff,n);
                     39:                lwrite(startad,n,buff);
                     40:                startad += 512;
                     41:        }
                     42: }
                     43: rt_init()
                     44: {
                     45:        static initized = 0;
                     46:        int mode = 2;
                     47: 
                     48:        if(initized) return;
                     49:        initized = 1;
                     50:        if((floppydes = open(flopname,mode)) < 0) {
                     51:                printf("Floppy open failed\n");
                     52:                exit(1);
                     53:        }
                     54: }
                     55:                
                     56: long trans(logical)
                     57: register int logical;
                     58: {
                     59:        /*  Logical to physical adress translation */
                     60:        register int sector, bytes, track;
                     61: 
                     62:        logical += 26 * 128;
                     63:        bytes = (logical & 127);
                     64:        logical >>= 7;
                     65:        sector = logical % 26;
                     66:        if(sector >= 13)
                     67:                sector = sector *2 +1;
                     68:        else
                     69:                sector *= 2;
                     70:        sector += 26 + ((track = (logical / 26)) - 1) * 6;
                     71:        sector %= 26;
                     72:        return( (((track *26) + sector) << 7) + bytes);
                     73: }
                     74: lread(startad,count,obuff)
                     75: register startad, count;
                     76: register char * obuff;
                     77: {
                     78:        long trans();
                     79:        extern floppydes;
                     80:        rt_init();
                     81:                while( (count -= 128) >= 0) {
                     82:                        lseek(floppydes, trans(startad), 0);
                     83:                        read(floppydes,obuff,128);
                     84:                        obuff += 128;
                     85:                        startad += 128;
                     86:                }
                     87: }
                     88: lwrite(startad,count,obuff)
                     89: register startad, count;
                     90: register char * obuff;
                     91: {
                     92:        long trans();
                     93:        extern floppydes;
                     94:        rt_init();
                     95:                while( (count -= 128) >= 0) {
                     96:                        lseek(floppydes, trans(startad), 0);
                     97:                        write(floppydes,obuff,128);
                     98:                        obuff += 128;
                     99:                        startad += 128;
                    100:                }
                    101: }

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