home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 2 / ctrom_ii_b.zip / ctrom_ii_b / PROGRAM / C / C-FDC / FDC.C < prev    next >
Text File  |  1985-05-28  |  5KB  |  262 lines
  1. /* fast multiple disk copy program */
  2. #include <stdio.h>
  3. #include "fdc.h"
  4.  
  5. #define PROG "fdc"
  6. #define VERSION "0.01"
  7. #define MAX_DRIVES 2;
  8.  
  9. struct ati *sp;
  10. int max_sect;
  11. int sect_size;
  12. int sect_type;
  13. int sides;
  14. int dasd_drv[MAXDRIVES];
  15. extern int secsize[];
  16.  
  17. main(argc, argv)
  18. int argc;
  19. char **argv;
  20. {
  21.  
  22.     int mfd;                            /* memory file fd                    */
  23.     int s_drive, d_drive;        /* source & destination drives */
  24.     int s_drv_num, d_drv_num;    /* source & destination drive # */
  25.     long disk_size;                /* size of disk in bytes        */
  26.  
  27.     
  28.     if(argc == 2) {
  29.         s_drive = *argv[1];
  30.         d_drive = s_drive;
  31.     } else if(argc == 3) {
  32.         s_drive = *argv[1];
  33.         d_drive = *argv[2];
  34.     } else {
  35.         printf("%s (v%s)\n", PROG, VERSION);
  36.         exit(0);
  37.     }
  38.     s_drv_num = tolower(s_drive) - 'a' + 1;
  39.     d_drv_num = tolower(d_drive) - 'a' + 1;
  40.     checkdrives(s_drv_num, d_drv_num);
  41.     disk_size = 9l * 512l * 2l;        /* dirty way to get max disk size */
  42.     if((mfd = getmspace(disk_size)) == EOF)
  43.         exit(1);
  44.     signon(s_drive, d_drive);
  45.     if(!psdisk(s_drive)) {
  46.         gdtype(s_drv_num);
  47.         dsetup(d_drv_num);
  48.         if(!readdisk(s_drv_num, mfd)) {
  49.             pddisk(d_drive);
  50.             diskcopy(d_drv_num, mfd);
  51.         }
  52.     }
  53.     if(mfd) 
  54.         cleanup(mfd);
  55.     signoff();
  56.     exit(0);
  57. }
  58.  
  59. int checkdrives(s_drv, d_drv)
  60. int s_drv, d_drv;
  61. {
  62.  
  63.     int i;
  64.     for(i = 0; i < MAXDRIVES; ++i) 
  65.         dasd_drv[i] = getdasd(i);
  66.     if(!dasd_drv[s_drv] || !dasd_drv[d_drv]) {
  67.         printf("Invalid drive specified!\n");
  68.         exit(1);
  69.     }
  70. }
  71.  
  72. int cleanup(fd)
  73. int fd;
  74. {
  75.  
  76.     restoredpb();
  77.     close(fd);
  78. }
  79.  
  80. int diskcopy(drive, mfd)
  81. int drive, mfd;
  82. {
  83.     /* fill in later */
  84. }
  85.  
  86.  
  87. int dsetup(drv_num)
  88. int drv_num;
  89. {
  90.  
  91.     static first = 0;
  92.     struct dpb *dp;
  93.     extern struct dpb dsk_p_blk[];
  94.  
  95.  
  96.     if(!first) {
  97.         setdbp();
  98.         ++first;
  99.     }
  100.     dp = &dsk_p_blk[drv_num];
  101.     if((sp->media_type & 0xff) != 0xf9) {
  102.         dp->sector_type = sect_type;
  103.         dp->format_gap_length = 0x50;
  104.         dp->eot = max_sect;
  105.     }
  106.     if(dasd_drv[drv_num] > 1)            /* a 1.2 M disk drive */
  107.         setdasd(drv_num, 2);                /* a 320/360 in a 1.2M */
  108.     else
  109.         setdasd(drv_num, 1);                /* a 320/360 in 320/360 drive */
  110.  
  111. }
  112.  
  113. int gdtype(s_drive)
  114. int s_drive;
  115. {
  116.     int i;        
  117.     struct ati *getati();
  118.  
  119.     sp = getati(s_drive);
  120.     sect_size = sp->sector_size;
  121.     switch(sp->media_type & 0xff) {
  122.         case 0xff:
  123.             sides = 2;
  124.             max_sect = 8;
  125.             break;
  126.         case 0xfe:
  127.             sides = 1;
  128.             max_sect = 8;
  129.             break;
  130.         case 0xfd:
  131.             sides = 2;
  132.             max_sect = 9;
  133.             break;
  134.         case 0xfc:
  135.             sides = 1;
  136.             max_sect = 9;
  137.             break;
  138.         case 0xf9:
  139.             sides = 2;
  140.             max_sect = 15;
  141.             break;
  142.         case 0xf8:
  143.             printf("Trying to fdc the hard disk, eh?\n");
  144.             exit(0);
  145.         default:
  146.             printf("Hummmm. I don't recognize the disk type, %x.\n", 
  147.                 sp->media_type);
  148.             exit(0);
  149.     }
  150.     for(i = 0; secsize[i]; ++i)
  151.         if(secsize[i] = sp->sector_size) {
  152.             sect_type = i;
  153.             break;
  154.         }
  155.     if(i && !sect_type) {
  156.         printf("Hummm. I don't recognize this sector size, %d\n", 
  157.             sp->sector_size);
  158.         exit(0);
  159.     }
  160.     printf("Copying %d side(s), %d sector/track\n", sides, max_sect);
  161.  
  162. }            
  163.  
  164. int getmspace(space)
  165. long space;
  166. {
  167.  
  168.     long msize();
  169.  
  170.     if(msize() < space) {
  171.         printf("Not enough memory for the copy!\n");
  172.         return(EOF);
  173.     }
  174.     return(mopen(space));
  175. }
  176.  
  177. int psdisk(source)
  178. int source;
  179. {
  180.  
  181.     return(pdisk("SOURCE", source));
  182.  
  183. }
  184.  
  185. int pddisk(destination)
  186. int destination;
  187. {
  188.  
  189.     return(pdisk("DESTINATION", destination));
  190.  
  191. }
  192.  
  193.  
  194. int pdisk(type, drive)
  195. char *type;
  196. int drive;
  197. {
  198.     int i;
  199.  
  200.     printf("Please insert the %s diskette into drive %c\n", 
  201.         type, toupper(drive));
  202.     printf("Hit Enter to start, A to abort ");
  203.     for( ; ; ) {
  204.         i = getch();
  205.         if(i == '\r') {
  206.             putchar('\n');
  207.             return(0);
  208.         }        
  209.         if(i == tolower('a')) {
  210.             putchar('\n');
  211.             return(-1);
  212.         }
  213.     }
  214. }
  215.  
  216.  
  217. int readdisk(drive, mfd)
  218. int drive, mfd;
  219. {
  220.  
  221.     int head, track;
  222.     int tracksize;
  223.     char *buf;
  224.     char *malloc();
  225.  
  226.     tracksize = sect_size * max_sect;
  227.     if((buf = malloc(tracksize)) == NULL) {
  228.         printf("Cannot create temp area!\n");
  229.         return(-1);
  230.     }
  231.  
  232.     for(track = 0; track < 39; ++track)
  233.         for(head = 0; head < sides; ++head) {
  234.             if(rdtrack(drive, head, track, 1, max_sect, buf)) {
  235.                 printf("Error in reading disk!\n");
  236.                 return(-1);
  237.             }
  238.             if(write(mfd, buf, tracksize) != tracksize) {
  239.                 printf("Error writing to memfile!\n");
  240.                 return(-1);
  241.             }  
  242.         }
  243.     free(buf);
  244.     return(0);
  245. }
  246.  
  247. int signoff()
  248. {
  249.  
  250.     printf("Thank you for using %s\n", PROG);
  251.  
  252. }
  253.  
  254. int signon(source, destination)
  255. int source, destination;
  256. {
  257.     printf("%s (v%s)\n", PROG, VERSION);
  258.     printf("Will copy %c: ==> %c:\n", source, destination);
  259. }
  260.     
  261.  
  262.