开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘编程 > 查看源码
hdtool.c
资源名称：disk.zip　[点击查看]
上传用户：tjzyjsm
上传日期：2007-02-22
资源大小：6k
文件大小：24k
源码类别：

磁盘编程

开发平台：

DOS

hdtool.c：源码内容
  1. /*
  2.    HDTOOL.C --- Hard disk tools Ver 1.1
  3.    (C) M.L.Y  2000.8, 2001.6
  4. */
  6. #include "HDTOOL.H"
  8. USGC rwv_buf[63*0x0200];
  9. char help_msg[] =
  10. "HDTOOL --- Hard disk tools Ver 1.1n"
  11. "(C) M.L.Y  2000.8, 2001.6nn"
  12. "Usage: HDTOOL func disk_no other_parms...n"
  13. " 1.Read test total disk:n"
  14. "   HDTOOL 1 disk_non"
  15. " 2.Clone (copy sector by sector: 80->81, 81->80, etc):n"
  16. "   HDTOOL 2 src_disk_no dest_disk_no [LBA_begin [LBA_end]]n"
  17. " 3.Format a track:n"
  18. "   HDTOOL 3 disk_no cyl_no head_non"
  19. " 4.Display a sector:n"
  20. "   HDTOOL 4 disk_no cyl_no head_no sector_non"
  21. " 5.Backup a sector to file:n"
  22. "   HDTOOL 5 disk_no cyl_no head_no sector_no filenamen"
  23. " 6.Restore a sector from file:n"
  24. "   HDTOOL 6 disk_no cyl_no head_no sector_no filenamen"
  25. " 7.Backup a track to file:n"
  26. "   HDTOOL 7 disk_no cyl_no head_no filenamen"
  27. " 8.Restore a track from file:n"
  28. "   HDTOOL 8 disk_no cyl_no head_no filenamen"
  29. "where: disk_no: 0=A,1=B,80-83=hard disk no 1-4n";
  31. int main(int argc,char **argv)
  32. {
  34. int  writeflag=2;
  36.   int  func, drv = 0, drv2 = 0, head = -1, sec = 0;
  37.   long cyl = -1;
  38.   char filename[256];
  39.   int  rc = 0, i, n;
  40.   USGI cyl_num[4], head_num[4], sec_num[4], drvnum;
  41.   int  ext_ver[4];
  42.   USGI phy_cyl[4], phy_head[4], phy_sec[4];
  43.   USGL LBA_sec_numL[4], LBA_sec_numH[4], MB;
  44.   USGL sabn = 0;             /* starting absolute block number */
  45.   USGL LBA_begin = 0L, LBA_end = 0L;
  46.   char *endptr;
  47. /* if (argc<4)
  48. {
  49. printf("Usage:%s R/W A/B FileName Flagn",argv[0]);
  50. return -1;
  51. }
  52. */
  53.   if(argc == 1)
  54.   {
  55.     printf(help_msg);
  56.     printf("nPress any key to continue ...n");
  57.     getch();
  58.     for(i = 0; i < 4; i++)
  59.     {
  60.       printf("Get hard disk %d parm: ", i+1);
  61.       rc = get_drv_parm(0x80+i,
  62.                         &cyl_num[i], &head_num[i], &sec_num[i], &drvnum,
  63.                         &phy_cyl[i], &phy_head[i], &phy_sec[i],
  64.                         &ext_ver[i], &LBA_sec_numL[i], &LBA_sec_numH[i]);
  65.       if(rc < 0)
  66.         printf("Error!n");
  67.       else
  68.       {
  69.         printf("Cyl=%d, head=%d, sec=%d, drv num=%dn",
  70.                cyl_num[i], head_num[i], sec_num[i], drvnum);
  71.         if(ext_ver[i] > 0)
  72.         {
  73.           MB = LBA_sec_numL[i] / 2 / 1024;
  74.           printf("(Ext: Cyl=%d, head=%d, sec=%d, LBA sectors: ",
  75.                  phy_cyl[i], phy_head[i], phy_sec[i]);
  76.           if(LBA_sec_numH[i] > 0)
  77.             printf("Too big.");
  78.           else
  79.             printf("%lu (%lu MB)", LBA_sec_numL[i], MB);
  80.           printf(")n");
  81.         }
  82.       }
  83.     }
  84.     return 0;
  85.   }
  86.   if(argc < 3) rc = -1;
  87.   else
  88.   {
  89.     func = atoi(argv[1]);
  91. if (func<0)
  92. {
  93. writeflag=3;
  94. func=func*(-1);
  95. }
  96. else writeflag=2;
  98.     if(func < 1 || func > 8) rc = -1;
  99.     else drv = atoi(argv[2]);
  100.     if(argc >= 4)
  101.     {
  102.       if(func == 2) drv2 = atoi(argv[3]);
  103.       else          cyl = atoi(argv[3]);
  104.     }
  105.     if(argc >= 5)
  106.     {
  107.       if(func == 2) LBA_begin = strtoul(argv[4], &endptr, 0);
  108.       else          head = atoi(argv[4]);
  109.     }
  110.     if(argc >= 6)
  111.     {
  112.       if(func >= 7 && func <= 8) strcpy(filename, argv[5]);
  113.       else if(func == 2)         LBA_end = strtoul(argv[5], &endptr, 0);
  114.       else                       sec = atoi(argv[5]);
  115.     }
  116.     if(func >= 5 && func <= 6 && argc >= 7) strcpy(filename, argv[6]);
  117.     if((func == 2 && argc < 3) || (func == 3 && argc < 4) ||
  118.        (func == 4 && argc < 5) || (func >= 5 && func <= 6 && argc < 7) ||
  119.        (func >= 7 && func <= 8 && argc < 6))
  120.       rc = -1;
  121.   }
  122.   if(rc >= 0)
  123.   {
  124.     if(!((drv >= 0 && drv <= 1) || (drv >= 80 && drv <= 83))) rc = -1;
  125.     if(func == 2 && !(drv >= 80 && drv2 >= 80 && drv2 != drv)) rc = -1;
  126.     if(func >= 3 && func <= 8 && (cyl < 0 || head < 0)) rc = -1;
  127.     if((func >= 4 && func <= 6) && sec <= 0) rc = -1;
  128.   }
  129.   if(rc < 0)
  130.   {
  131.     printf(help_msg);
  132.     return 0;
  133.   }
  134.   if(drv >= 80) drv = drv - 80 + 0x80;
  135.   if(drv2 >= 80) drv2 = drv2 - 80 + 0x80;
  136.   rc = get_drv_parm(drv, &cyl_num[0], &head_num[0], &sec_num[0], &drvnum,
  137.     &phy_cyl[0], &phy_head[0], &phy_sec[0],
  138.     &ext_ver[0], &LBA_sec_numL[0], &LBA_sec_numH[0]);
  139.   if(func == 2 && drvnum < 2)
  140.   {
  141.     printf("Error: you have only %d hard disk!n", drvnum);
  142.     return -1;
  143.   }
  144.   if(rc < 0)
  145.   {
  146.     printf("Get drive parm. error!n");
  147.     return -1;
  148.   }
  149.   if(ext_ver[0] > 0)
  150.   {
  151.     cyl_num[0] = phy_cyl[0];
  152.     head_num[0] = phy_head[0];
  153.     sec_num[0] = phy_sec[0];
  154.     if(LBA_sec_numH[0] > 0)
  155.     {
  156.       printf("Hard disk too big.n");
  157.       return -2;
  158.     }
  159.   }
  160.   if(func == 2)
  161.   {
  162.     rc = get_drv_parm(drv2, &cyl_num[1], &head_num[1], &sec_num[1], &drvnum,
  163.                       &phy_cyl[1], &phy_head[1], &phy_sec[1],
  164.                       &ext_ver[1], &LBA_sec_numL[1], &LBA_sec_numH[1]);
  165.     if(rc < 0)
  166.     {
  167.       printf("Get drive parm. error!n");
  168.       return -1;
  169.     }
  170.     if(ext_ver[1] > 0)
  171.     {
  172.       cyl_num[1] = phy_cyl[1];
  173.       head_num[1] = phy_head[1];
  174.       sec_num[1] = phy_sec[1];
  175.       if(LBA_sec_numH[1] > 0)
  176.       {
  177.         printf("Hard disk too big.n");
  178.         return -2;
  179.       }
  180.     }
  181.   }
  182.   if(func == 1)
  183.   /*
  184.     read_test_disk(drv, cyl_num[0], head_num[0], sec_num[0],
  185.                    ext_ver[0], LBA_sec_numL[0]);
  186.   */
  187. if (writeflag==3)
  188. {
  189. WriteFloppyFromFile(drv, cyl_num[0], head_num[0], sec_num[0],
  190.                    ext_ver[0], LBA_sec_numL[0],argv[3]);
  191. }
  192. else
  193. ReadFloppyToFile(drv, cyl_num[0], head_num[0], sec_num[0],
  194.                    ext_ver[0], LBA_sec_numL[0],argv[3]);
  195.   if(func == 2)
  196.   {
  197.     if((cyl_num[0] < cyl_num[1] &&
  198.         head_num[0] < head_num[1] &&
  199.         sec_num[0] < sec_num[1]) ||
  200.        (cyl_num[0] >= cyl_num[1] &&
  201.         head_num[0] >= head_num[1] &&
  202.         sec_num[0] >= sec_num[1]))
  203.     {
  204.       if(LBA_end == 0) LBA_end = min(LBA_sec_numL[0], LBA_sec_numL[1]);
  205.       printf("Clone hard disk: 0x%02X -> 0x%02X (LBA from %lu to %lu),"
  206. " are you sure(Y/N)? ", drv, drv2, LBA_begin, LBA_end);
  207.       gets(filename);
  208.       if(filename[0] != 'y' && filename[0] != 'Y') return 0;
  209.       hd_clone(drv, cyl_num[0], head_num[0], sec_num[0],
  210.                ext_ver[0], LBA_sec_numL[0],
  211.                drv2, cyl_num[1], head_num[1], sec_num[1],
  212.                ext_ver[1], LBA_sec_numL[1],
  213.                LBA_begin, LBA_end);
  214.     }
  215.     else
  216.     {
  217.       printf("Error: 2 disks parm. do not match!n");
  218.       return -1;
  219.     }
  220.   }
  221.   if(func == 3)
  222.   {
  223.     rc = format_cyl(drv, cyl, head, sec_num[0], ext_ver[0]);
  224.     if(rc < 0)
  225.     {
  226.       printf("Error!n");
  227.       return -1;
  228.     }
  229.     printf("Ok!n");
  230.   }
  231.   if(func == 4)
  232.   {
  233.     if(ext_ver[0] > 0)
  234.     {
  235.       sabn = cyl;
  236.       sabn = (sabn * head_num[0] + head) * sec_num[0] + sec - 1;
  237.     }
  238.     rc = rwv_disk_sect(2, drv, cyl, head, sec, 1, rwv_buf, ext_ver[0], sabn);
  239.     if(rc == 0)
  240.       disp_hex(rwv_buf, 0x0200);
  241.     else
  242.       printf("Error!n");
  243.   }
  244.   if(func == 5 || func == 7)
  245.   {
  246.     n = 1;
  247.     if(func == 7)
  248.     {
  249.       sec = 1;
  250.       n = sec_num[0];
  251.     }
  252.     if(ext_ver[0] > 0)
  253.     {
  254.       sabn = cyl;
  255.       sabn = (sabn * head_num[0] + head) * sec_num[0] + sec - 1;
  256.     }
  257.     rc = rwv_disk_sect(2, drv, cyl, head, sec, n, rwv_buf, ext_ver[0], sabn);
  258.     if(rc < 0)
  259.     {
  260.       printf("Reading disk error!n");
  261.       return -1;
  262.     }
  263.     else
  264.       rc = wrt_buf2file(filename, rwv_buf, n*0x0200);
  265.   }
  266.   if(func == 6 || func == 8)
  267.   {
  268.     n = 1;
  269.     if(func == 8)
  270.     {
  271.       sec = 1;
  272.       n = sec_num[0];
  273.     }
  274.     rc = read_file2buf(filename, rwv_buf, n*0x0200);
  275.     if(rc >= 0)
  276.     {
  277.       if(ext_ver[0] > 0)
  278.       {
  279.         sabn = cyl;
  280.         sabn = (sabn * head_num[0] + head) * sec_num[0] + sec - 1;
  281.       }
  282.       rc = rwv_disk_sect(3, drv, cyl, head, sec, n, rwv_buf, ext_ver[0], sabn);
  283.       if(rc < 0)
  284.       {
  285.         printf("Reading disk error!n");
  286.         return -1;
  287.       }
  288.     }
  289.   }
  290.   return 0;
  291. }
  293. /* ------------------------------------------------------------------------- */
  294. int  int13_ext_chk(USGC drv_no, int *ext_ver)
  295. {
  296.   union REGS inregs, outregs;
  297.   struct SREGS segregs;
  299.   inregs.h.ah = 0x41;
  300.   inregs.x.bx = 0x55AA;
  301.   inregs.h.dl = drv_no;
  302.   int86x(0x13, &inregs, &outregs, &segregs);
  303.   if(outregs.x.cflag) return -1;
  304.   if(outregs.x.bx != 0xAA55) return -1;
  305.   *ext_ver = outregs.h.ah;
  306.   return 0;
  307. }
  309. /* ------------------------------------------------------------------------- */
  310. int  get_drv_parm(USGC drv_no, USGI *cyl, USGI *head, USGI *sec, USGI *drvnum,
  311.                   USGI *phy_cyl, USGI *phy_head, USGI *phy_sec,
  312.                   int *ext_ver, USGL *LBA_sec_numL, USGL *LBA_sec_numH)
  313. {
  314.   union REGS inregs, outregs;
  315.   struct SREGS segregs;
  316.   USGC para_buf[0x42];
  318.   *ext_ver = 0;
  319.   *phy_cyl = 0;
  320.   *phy_head = 0;
  321.   *phy_sec = 0;
  322.   *LBA_sec_numL = 0;
  323.   *LBA_sec_numH = 0;
  324.   inregs.h.ah = 0x08;
  325.   inregs.h.dl = drv_no;
  326.   int86x(0x13, &inregs, &outregs, &segregs);
  327.   if(outregs.x.cflag) return -1;
  328.   *cyl = (outregs.h.cl >> 6 << 8 | outregs.h.ch) + 1;
  329.   *sec = outregs.h.cl & 0x3F;
  330.   *head = outregs.h.dh + 1;
  331.   *drvnum = outregs.h.dl;
  332.   if(int13_ext_chk(drv_no, ext_ver) < 0)
  333.   {
  334.     *ext_ver = 0;
  335.     return 0;
  336.   }
  337.   memset(para_buf, 0x00, sizeof(para_buf));
  338.   if(*ext_ver == 0x01)
  339.     *(int *)para_buf = 0x001A;
  340.   else if(*ext_ver == 0x20 || *ext_ver == 0x21)
  341.     *(int *)para_buf = 0x001E;
  342.   else /* *ext_ver == 30h */
  343.     *(int *)para_buf = 0x0042;
  344.   inregs.x.si = FP_OFF(para_buf);
  345.   segregs.ds = FP_SEG(para_buf);
  346.   inregs.h.dl = drv_no;
  347.   inregs.h.ah = 0x48;
  348.   int86x(0x13, &inregs, &outregs, &segregs);
  349.   if(outregs.x.cflag)
  350.   {
  351.     *ext_ver = 0;
  352.     return 0;
  353.   }
  354.   *phy_cyl = *(USGL *)(para_buf+0x04);
  355.   *phy_head = *(USGL *)(para_buf+0x08);
  356.   *phy_sec = *(USGL *)(para_buf+0x0C);
  357.   *LBA_sec_numL = *(USGL *)(para_buf+0x10);
  358.   *LBA_sec_numH = *(USGL *)(para_buf+0x14);
  359.   return 0;
  360. }
  362. /* ------------------------------------------------------------------------- */
  363. int  rwv_disk_sect(USGC rwv, USGC drv_no, USGI cyl, USGC head, USGC sec,
  364.                    USGC sec_num, USGC *buf, int ext_ver, USGL sabn)
  365. {
  366.   union REGS inregs, outregs;
  367.   struct SREGS segregs;
  368.   int  i, rc;
  369.   USGC pkt_buf[0x18];
  370. printf("nrwv=%d drv_no=%d cyl=%d head=%d sec=%d sec_num=%d ext_ver=%d",
  371. rwv,drv_no,cyl,head,sec,sec_num,ext_ver);
  372.   for(i = 0; i < 3; i++)
  373.   {
  374.     rc = 0;
  375.     if(ext_ver == 0)
  376.     {
  377.       inregs.h.ah = rwv;     /* 2 -- read, 3 -- write, 4 -- verify */
  378.       inregs.h.al = sec_num;
  379.       inregs.h.dh = head;
  380.       inregs.h.dl = drv_no;
  381.       inregs.h.ch = cyl & 0xFF;
  382.       inregs.h.cl = cyl >> 8 << 6 | sec;
  384.   inregs.x.bx = FP_OFF(buf);
  385.       segregs.es = FP_SEG(buf);
  387.   int86x(0x13, &inregs, &outregs, &segregs);
  388.       printf("n-----[%02X]-----n",buf[10]);
  389.   if(!outregs.x.cflag) break;
  390.     }
  391.     else
  392.     {
  393.       memset(pkt_buf, 0x00, sizeof(pkt_buf));
  394.       *(int *)pkt_buf = 0x0018;
  395.       *(int *)(pkt_buf+0x02) = sec_num;
  396.       *(USGI *)(pkt_buf+0x04) = FP_OFF(buf);
  397.       *(USGI *)(pkt_buf+0x06) = FP_SEG(buf);
  398.       *(USGL *)(pkt_buf+0x08) = sabn;
  399.       inregs.h.dl = drv_no;
  400.       inregs.x.si = FP_OFF(pkt_buf);
  401.       segregs.ds = FP_SEG(pkt_buf);
  402.       inregs.h.ah = rwv + 0x40; /* 42h -- read, 43h -- write, 44h -- verify */
  403.       inregs.h.al = 0;
  404.       int86x(0x13, &inregs, &outregs, &segregs);
  405.       if(!outregs.x.cflag) break;
  406.     }
  407.     rc = -1;
  408.     inregs.h.ah = 0;
  409.     inregs.h.dl = drv_no;
  410.     int86x(0x13, &inregs, &outregs, &segregs);
  411.   }
  412.   return rc;
  413. }
  415. /* ------------------------------------------------------------------------- */
  416. int  format_cyl(USGC drv_no, USGI cyl, USGC head, USGC sec_num, int ext_ver)
  417. {
  418.   union REGS inregs, outregs;
  419.   struct SREGS segregs;
  420.   int  i, rc;
  421.   USGC format_buf[63*4];
  423.   if(ext_ver > 0) return -2; /* Not support now */
  424.   if(drv_no < 0x80)          /* floppy disk */
  425.   {
  426.     for(i = 0; i < sec_num; i++)
  427.     {
  428.       format_buf[i*4+0] = cyl;
  429.       format_buf[i*4+1] = head;
  430.       format_buf[i*4+2] = i+1;
  431.       format_buf[i*4+3] = 0x02; /* sector size (02h=512) */
  432.     }
  433.   }
  434.   else                       /* fixed disk (hard disk) */
  435.   {
  436.     for(i = 0; i < sec_num; i++)
  437.     {
  438.       format_buf[i*2+0] = 0x00; /* F = 00h for good sector, 80h for bad */
  439.       format_buf[i*2+1] = i+1;  /* N = sector number */
  440.     }
  441.   }
  442.   for(i = 0; i < 3; i++)
  443.   {
  444.     rc = 0;
  445.     inregs.h.ah = 0x07;      /* 5 -- format a cylinder */
  446.     if(drv_no < 0x80)        /* floppy disk */
  447.       inregs.h.al = sec_num;
  448.     else                     /* fixed disk (hard disk) */
  449.       inregs.h.al = 0x00;    /* interleave value (XT-type controllers only) */
  450.     inregs.h.dh = head;
  451.     inregs.h.dl = drv_no;
  452.     inregs.h.ch = cyl & 0xFF;
  453.     inregs.h.cl = cyl >> 8 << 6 | sec_num;
  454.     inregs.x.bx = FP_OFF(format_buf);
  455.     segregs.es = FP_SEG(format_buf);
  456.     int86x(0x13, &inregs, &outregs, &segregs);
  457.     if(!outregs.x.cflag) break;
  458.     rc = -1;
  459.     inregs.h.ah = 0;
  460.     inregs.h.dl = drv_no;
  461.     int86x(0x13, &inregs, &outregs, &segregs);
  462.   }
  463.   return rc;
  464. }
  466. /* ------------------------------------------------------------------------- */
  467. int  ReadFloppyToFile(USGC drv, USGI cyl_num, USGI head_num, USGI sec_num,
  468.                     int ext_ver, USGL LBA_sec_num,char * FileName)
  469. {
  470.   int  i, j, k, rc = 0, rc1,l;
  471.   USGL n;
  473.   FILE * f;
  476.   if(ext_ver > 0)
  477.   {
  478.     for(n = 0; n < LBA_sec_num; n++)
  479.     {
  480.       printf("Reading LBA block no: %lu -- ", n);
  481.       rc1 = rwv_disk_sect(2, drv, 0, 0, 0, 1, rwv_buf, ext_ver, n);
  482.       if(rc1 == 0) printf("ok!n");
  483.       else
  484.       {
  485.         printf("error!n");
  486.         rc++;
  487.         if(rc > 10)
  488.         {
  489.           printf("Errors > 10!n");
  490.           return -1;
  491.         }
  492.       }
  493.     }
  494.     return 0;
  495.   }
  496.   f=fopen(FileName,"w+b");
  497.   if(f==NULL)
  498. {
  499.   perror(FileName);
  500.   return -1;
  501. }
  502.   for(i = 0; i < cyl_num; i++)
  503.     for(j = 0; j < head_num; j++)
  504.       for(k = 1; k <= sec_num; k++)
  505.       {
  506.         //printf("Reading cyl:%d, head:%d, sector:%d -- ", i, j, k);
  507.         rc1 = rwv_disk_sect(2, drv, i, j, k, 1, rwv_buf, 0, 0);
  508.         if(rc1 == 0) 
  509.   {
  510. //printf("ok!n");
  511. for (l=0;l<0x0200 ;l++ )
  512. {
  513. fprintf(f,"%c",rwv_buf[i]);
  514. printf("%02X ",rwv_buf[i]);
  515. }
  516. //fwrite(rwv_buf,1,0x0200,f);
  517.   }
  518.         else
  519.         {
  520.           printf("error!n");
  521.           rc++;
  522.           if(rc > 10)
  523.           {
  524.   fclose(f);
  525.             printf("Errors > 10!n");
  526.             return -1;
  527.           }
  528.         }
  529.       }
  530.   fclose(f);
  531.   return 0;
  532. }
  533. int  WriteFloppyFromFile(USGC drv, USGI cyl_num, USGI head_num, USGI sec_num,
  534.                     int ext_ver, USGL LBA_sec_num,char * FileName)
  535. {
  536.   int  i, j, k, rc = 0, rc1,l;
  537.   USGL n;
  539.   FILE * f;
  542.   if(ext_ver > 0)
  543.   {
  544.     for(n = 0; n < LBA_sec_num; n++)
  545.     {
  546.       printf("Reading LBA block no: %lu -- ", n);
  547.       rc1 = rwv_disk_sect(2, drv, 0, 0, 0, 1, rwv_buf, ext_ver, n);
  548.       if(rc1 == 0) printf("ok!n");
  549.       else
  550.       {
  551.         printf("error!n");
  552.         rc++;
  553.         if(rc > 10)
  554.         {
  555.           printf("Errors > 10!n");
  556.           return -1;
  557.         }
  558.       }
  559.     }
  560.     return 0;
  561.   }
  562.   f=fopen(FileName,"rb");
  563.   if(f==NULL)
  564. {
  565.   perror(FileName);
  566.   return -1;
  567. }
  568.   for(i = 0; i < cyl_num; i++)
  569.     for(j = 0; j < head_num; j++)
  570.       for(k = 1; k <= sec_num; k++)
  571.       {
  572.         //printf("Reading cyl:%d, head:%d, sector:%d -- ", i, j, k);
  573. fread(rwv_buf,1,0x0200,f);
  574. for (l=0;l<0x0200 ;l++ )
  575. {
  576. printf("%02X ",rwv_buf[l]);
  577. }
  578.         rc1 = rwv_disk_sect(3, drv, i, j, k, 1, rwv_buf, 0, 0);
  579.         if(rc1 == 0) 
  580.   {
  581. //printf("ok!n");
  582.   }
  583.         else
  584.         {
  585.           printf("error!n");
  586.           rc++;
  587.           if(rc > 10)
  588.           {
  589.   fclose(f);
  590.             printf("Errors > 10!n");
  591.             return -1;
  592.           }
  593.         }
  594.       }
  595.   fclose(f);
  596.   return 0;
  597. }
  599. /* ------------------------------------------------------------------------- */
  600. int  read_test_disk(USGC drv, USGI cyl_num, USGI head_num, USGI sec_num,
  601.                     int ext_ver, USGL LBA_sec_num)
  602. {
  603.   int  i, j, k, rc = 0, rc1;
  604.   USGL n;
  607.   if(ext_ver > 0)
  608.   {
  609.     for(n = 0; n < LBA_sec_num; n++)
  610.     {
  611.       printf("Reading LBA block no: %lu -- ", n);
  612.       rc1 = rwv_disk_sect(2, drv, 0, 0, 0, 1, rwv_buf, ext_ver, n);
  613.       if(rc1 == 0) printf("ok!n");
  614.       else
  615.       {
  616.         printf("error!n");
  617.         rc++;
  618.         if(rc > 10)
  619.         {
  620.           printf("Errors > 10!n");
  621.           return -1;
  622.         }
  623.       }
  624.     }
  625.     return 0;
  626.   }
  627.   for(i = 0; i < cyl_num; i++)
  628.     for(j = 0; j < head_num; j++)
  629.       for(k = 1; k <= sec_num; k++)
  630.       {
  631.         printf("Reading cyl:%d, head:%d, sector:%d -- ", i, j, k);
  632.         rc1 = rwv_disk_sect(2, drv, i, j, k, 1, rwv_buf, 0, 0);
  633.         if(rc1 == 0) 
  634.   {
  635. printf("ok!n");
  636.   }
  637.         else
  638.         {
  639.           printf("error!n");
  640.           rc++;
  641.           if(rc > 10)
  642.           {
  643.             printf("Errors > 10!n");
  644.             return -1;
  645.           }
  646.         }
  647.       }
  648.   return 0;
  649. }
  651. /* ------------------------------------------------------------------------- */
  652. int  hd_clone(USGC drv1, USGI cyl_num1, USGI head_num1, USGI sec_num1,
  653.               int ext_ver1, USGL LBA_sec_num1,
  654.               USGC drv2, USGI cyl_num2, USGI head_num2, USGI sec_num2,
  655.               int ext_ver2, USGL LBA_sec_num2,
  656.               USGL LBA_begin, USGL LBA_end)
  657. {
  658.   int  i, j, k, r_err_num = 0, w_err_num = 0, rc1, rc2, disp = 0;
  659.   USGI cyl_num, head_num, sec_num;
  660.   USGL LBA_sec_num, n;
  661.   time_t timer;
  662.   struct tm *tms;
  663.   char time_buf1[20], time_buf2[20];
  665.   timer = time(NULL);
  666.   tms = localtime(&timer);
  667.   k = sprintf(time_buf1, "%4d-%02d-%02d %02d:%02d:%02d", tms->tm_year+1900,
  668.               tms->tm_mon+1, tms->tm_mday, tms->tm_hour, tms->tm_min,
  669.               tms->tm_sec);
  670.   time_buf1[k] = 0;
  672.   if(ext_ver1 != ext_ver2)
  673.   {
  674.     printf("Error: ext_ver1 != ext_ver2n");
  675.     return -1;
  676.   }
  677.   cyl_num = min(cyl_num1, cyl_num2);
  678.   head_num = min(head_num1, head_num2);
  679.   sec_num = min(sec_num1, sec_num2);
  680.   if(sec_num > 63)
  681.   {
  682.     printf("Error: sec_num > 63n");
  683.     return -1;
  684.   }
  685.   if(ext_ver1 > 0)
  686.   {
  687.     LBA_sec_num = min(LBA_sec_num1, LBA_sec_num2);
  688.     LBA_end = min(LBA_end, LBA_sec_num);
  689.     for(n = LBA_begin; n < LBA_end; disp++)
  690.     {
  691.       if(disp <= 0)
  692.         printf("rCopy from LBA block no: %lu, sectors: %d -- ", n, sec_num);
  693.       rc1 = rwv_disk_sect(2, drv1, 0, 0, 0, sec_num, rwv_buf, ext_ver1, n);
  694.       if(rc1 == 0)
  695.       {
  696.         rc2 = rwv_disk_sect(3, drv2, 0, 0, 0, sec_num, rwv_buf, ext_ver2, n);
  697.         if(rc2 == 0)
  698.         {
  699.           if(disp <= 0) printf("ok! ......");
  700.         }
  701.         else
  702.         {
  703.           w_err_num++;
  704.           if(disp > 0)
  705.             printf("nCopy from LBA block no: %lu, sectors: %d -- ",
  706.                    n, sec_num);
  707.           printf("write error!n");
  708.         }
  709.       }
  710.       else
  711.       {
  712.         r_err_num++;
  713.         if(disp > 0)
  714.           printf("nCopy from LBA block no: %lu, sectors: %d -- ", n, sec_num);
  715.         printf("read error!n");
  716.       }
  717.       if(r_err_num > 5)
  718.       {
  719.         printf("Read errors > 5!n");
  720.         return -1;
  721.       }
  722.       if(w_err_num > 5)
  723.       {
  724.         printf("Write errors > 5!n");
  725.         return -1;
  726.       }
  727.       n += sec_num;
  728.       if(disp >= 300) disp = -1;
  729.       if(n >= (LBA_end - sec_num - 1)) disp = -1;
  730.     }
  731.   }
  732.   else
  733.   {
  734.     for(i = 0; i < cyl_num; i++)
  735.       for(j = 0; j < head_num; j++)
  736.       {
  737.         k = 1;
  738.         printf("Copy from cyl:%d, head:%d, sectors:%d -- ", i, j, sec_num);
  739.         rc1 = rwv_disk_sect(2, drv1, i, j, k, sec_num, rwv_buf, 0, 0);
  740.         if(rc1 == 0)
  741.         {
  742.           rc2 = rwv_disk_sect(3, drv2, i, j, k, sec_num, rwv_buf, 0, 0);
  743.           if(rc2 == 0) printf("ok!n");
  744.           else
  745.           {
  746.             w_err_num++;
  747.             printf("write error!n");
  748.           }
  749.         }
  750.         else
  751.         {
  752.           r_err_num++;
  753.           printf("read error!n");
  754.         }
  755.         if(r_err_num > 5)
  756.         {
  757.           printf("Read errors > 5!n");
  758.           return -1;
  759.         }
  760.         if(w_err_num > 5)
  761.         {
  762.           printf("Write errors > 5!n");
  763.           return -1;
  764.         }
  765.       }
  766.   }
  767.   printf("nTotal errors: Read = %d, write = %dn", r_err_num, w_err_num);
  769.   timer = time(NULL);
  770.   tms = localtime(&timer);
  771.   k = sprintf(time_buf2, "%4d-%02d-%02d %02d:%02d:%02d", tms->tm_year+1900,
  772.               tms->tm_mon+1, tms->tm_mday, tms->tm_hour, tms->tm_min,
  773.               tms->tm_sec);
  774.   time_buf2[k] = 0;
  775.   printf("Time: from %s to %sn", time_buf1, time_buf2);
  776.   return 0;
  777. }
  779. /* ------------------------------------------------------------------------- */
  780. int  wrt_buf2file(char *filename, USGC *buf, USGI bytes)
  781. {
  782.   FILE *fp;
  784.   if((fp = fopen(filename, "wb")) == NULL)
  785.   {
  786.     printf("Create file error!n");
  787.     return -1;
  788.   }
  789.   if(fwrite(buf, 1, bytes, fp) != bytes)
  790.   {
  791.     printf("Write file error!n");
  792.     fclose(fp);
  793.     return -1;
  794.   }
  795.   if(fclose(fp) != 0)
  796.   {
  797.     printf("Close file error!n");
  798.     return -1;
  799.   }
  800.   printf("Ok!n");
  801.   return 0;
  802. }
  804. /* ------------------------------------------------------------------------- */
  805. int  read_file2buf(char *filename, USGC *buf, USGI bytes)
  806. {
  807.   FILE *fp;
  809.   if((fp = fopen(filename, "rb")) == NULL)
  810.   {
  811.     printf("Open file error!n");
  812.     return -1;
  813.   }
  814.   if(fread(buf, 1, bytes, fp) != bytes)
  815.   {
  816.     printf("Read file error!n");
  817.     fclose(fp);
  818.     return -1;
  819.   }
  820.   if(fclose(fp) != 0)
  821.   {
  822.     printf("Close file error!n");
  823.     return -1;
  824.   }
  825.   printf("Ok!n");
  826.   return 0;
  827. }
  829. /* ------------------------------------------------------------------------- */
  830. void disp_hex(USGC *buf, int len)
  831. {
  832.   USGC dispstr[8192];
  834.   DbgOutStrA(dispstr, buf, len, "", 4);
  835.   printf("%s", dispstr);
  836. }
  838. /* ------------------------------------------------------------------------- */
  839. int  sprintf_end(void *buffer, void *fmt, ...)
  840. /*
  841.    sprintf to buffer end
  843.    M.L.Y  1999.6.2
  844. */
  845. {
  846.   char tmpstr1[8192];
  847.   va_list arg_ptr;
  849.   va_start(arg_ptr, fmt);
  850.   vsprintf(tmpstr1, fmt, arg_ptr);
  851.   va_end(arg_ptr);
  852.   strcat(buffer, tmpstr1);
  853.   return 0;
  854. }
  856. /* ------------------------------------------------------------------------- */
  857. int  DbgOutStrA(USGC *buf, USGC *str, int str_len, char *ptr_left,
  858.                 int ptr_len)
  859. /*
  860.    Output an ASCII code string by DEBUG format to the buffer
  861.    Return: 0
  863.    M.L.Y  1995, 1999
  864. */
  865. {
  866.   int  j, k, ccpair = 0, ptr;
  867.   USGC buf1[1024];
  869.   buf[0] = '';
  870.   for(ptr = 0; ptr < str_len; )      /* pointer of this line of str */
  871.   {
  872.     if(str_len - ptr >= 16) k = 16;  /* length of this line of str */
  873.     else                    k = str_len - ptr;
  874.     sprintf_end(buf, "%s", ptr_left);
  875.     sprintf_end(buf, "%0*X ", ptr_len, ptr);
  876.     for(j = 0; j < 16; j++)  /* byte order of this line */
  877.     {
  878.       if(j < k)
  879.       {
  880.         if(j == 8) sprintf_end(buf, "-%02X", str[ptr + j]);
  881.         else       sprintf_end(buf, " %02X", str[ptr + j]);
  882.       }
  883.       else         sprintf_end(buf, "   ");
  884.     }
  885.     sprintf_end(buf, "  ");
  886.     buf1[0] = '';
  887.     for(j = 0; j < 16; j++)
  888.     {
  889.       if(j >= k) break;
  890.       if(j == 0 && ccpair > 0)
  891.       {
  892.         ccpair = 0;
  893.         goto dscc_dispul;
  894.       }
  895.       if(ccpair == 0)
  896.       {
  897.         if(str[ptr + j] > 0xA0 && str[ptr + j] < 0xFF)
  898.         {
  899.           if(str[ptr + j + 1] > 0xA0 && str[ptr + j + 1] < 0xFF)
  900.           {
  901.             ccpair = 1;        /* DBCS left byte */
  902.             goto dscc_dispch;
  903.           }
  904.           goto dscc_dispdot;
  905.         }
  906.         if(str[ptr + j] >= 0x20 && str[ptr + j] < 0x80) goto dscc_dispch;
  907.         goto dscc_dispdot;
  908.       }
  909.       ccpair = 0;              /* DBCS right byte */
  910.       goto dscc_dispch;
  911. dscc_dispul:  /* use the underline character instead */
  912.       /* sprintf_end(buf1, "_"); */
  913.       sprintf_end(buf1, "%c", 0x5F);
  914.       goto dscc_cont1;
  915. dscc_dispch:
  916.       sprintf_end(buf1, "%c", str[ptr + j]);
  917.       goto dscc_cont1;
  918. dscc_dispdot:
  919.       /* sprintf_end(buf1, "."); */
  920.       sprintf_end(buf1, "%c", 0x2E);
  921.       goto dscc_cont1;
  922. dscc_dispblk:
  923.       /* sprintf_end(buf1, " "); */
  924.       sprintf_end(buf1, "%c", 0x20);
  925. dscc_cont1:
  926.       ;
  927.     }
  928.     if(ccpair > 0 && k == 16)
  929.     {
  930.       sprintf_end(buf1, "%c", str[ptr + 16]);
  931.       /* output the first byte of next line (the DBCS right byte) */
  932.     }
  933.     strcat((char *)buf, (char *)buf1);
  934.     sprintf_end(buf, "n");
  935.     ptr = ptr + 16;
  936.   }
  937.   return 0;
  938. }
  940. /* End of file */