Восстановление bad секторов

////////////////////////////////////////////////////////////////////////////////
// main.cpp
//
// Программа проверит жесткий диск или любой другого накопитель.
// Интерфейс подобен программе "MHDD".
// Будет проверена скорость отклика, не будет произведена диагностика
// возможности чтения/записи - это нужно добавить вам, как и дополнительные
// функции - т.к. проверка ошибок.
 
#pragma comment(lib,"winmm.lib")
 
#include <windows.h>
#include <stdio.h>
#include <time.h>
#include <winioctl.h>
 
#define DRIVE       "\\\\.\\PhysicalDrive0"
#define BUFFSIZE    512
#define MAX_COLUMNS 49
#define MAX_ROWS 23
 
enum COLORS {
BLACK,
BLUE,
GREEN,
CYAN,
RED,
MAGENTA,
BROWN,
LIGHTGRAY,
DARKGRAY,
LIGHTBLUE,
LIGHTGREEN,
LIGHTCYAN,
LIGHTRED,
LIGHTMAGENTA,
YELLOW,
WHITE
};
 
void wrch(int x, int y, unsigned char* ch, int n, int clr);
DOUBLE appSeconds();
int GetStatus();
 
//
// Entry point
//
void main(void)
{
    char buf[BUFFSIZE];
 
    DWORD dwBytes, dw;
    DOUBLE StartSeconds, Total;
    LONG lDistanceToMove=0;
 
    // Access (read-write) mode
    DWORD dwDesiredAccess;
 
    dwDesiredAccess=0;      // No access to the drive
    //dwDesiredAccess=GENERIC_ALL;  // Read-write access!
 
    HANDLE hDevice=CreateFile(DRIVE,
    dwDesiredAccess,
    FILE_SHARE_READ |   // share mode
    FILE_SHARE_WRITE,
    NULL,           // pointer to security attributes)
    OPEN_EXISTING,      // Disposition (how to create)
    0,          // file attributes
    NULL);          // do not copy file attributes
 
    if(INVALID_HANDLE_VALUE==hDevice)
    {
        printf("Failed open \"%s\"\n",DRIVE);
        system("pause>nul");
        return;
    }
 
    DWORD BytesReturned;
 
    // Obtains information on the physical disk's geometry
 
    DWORD dwIoControlCode = IOCTL_DISK_GET_DRIVE_GEOMETRY;
    DISK_GEOMETRY dg;// Disk drive geometry structure
 
    LPVOID lpOutBuffer = &dg;
    DWORD nOutBufferSize = sizeof(dg);
 
    BOOL ret=DeviceIoControl(
    hDevice,            // handle to device of interest
    dwIoControlCode,        // control code of operation to perform
    NULL,           // pointer to buffer to supply input data
    0,          // size of input buffer
    lpOutBuffer,        // pointer to buffer to receive output data
    nOutBufferSize,     // size of output buffer
    &BytesReturned,     // pointer to variable to receive output byte count
    NULL);          // pointer to overlapped structure for asynchronous operation
 
    //CloseHandle(hDevice);
 
    if(!ret)
    {
        printf("Failed DeviceIoControl\nError %ld.\n",GetLastError());
        system("pause>nul");
        return;
    }
 
    ULONGLONG DiskSize;     // Size of the drive, in bytes
 
    DiskSize = dg.Cylinders.QuadPart *
    dg.TracksPerCylinder * dg.SectorsPerTrack * dg.BytesPerSector;
 
    printf("Start check sector\n");
 
    unsigned char B0[1] = { 0xB0 };
    unsigned char B1[1] = { 0xB1 };
    unsigned char B2[1] = { 4 };
    unsigned char space[1] = { 0x20 };
 
    int col, row, status;
    col=0;
    row=2;
 
    unsigned char leg[] ="Legenda";
    unsigned char ms3[5] = { 0xB0, '<', '3', 'm', 's'};
    unsigned char ms10[6] = { 0xB1, '<', '1', '0', 'm', 's'};
    unsigned char ms50[6] = { 0x4, '<', '5', '0', 'm', 's'};
 
    unsigned char squ[1] = { 0xB1 };
    unsigned char ms150[6] = { '<', '1', '5', '0', 'm', 's'};
    unsigned char ms500[6] = { '<', '5', '0', '0', 'm', 's'};
    unsigned char ms500_2[6] = { '>', '5', '0', '0', 'm', 's'};
 
    wrch(60, 0, leg, 7, LIGHTGRAY);
 
    // <3 Ms
    wrch(60, 2, ms3, 5, LIGHTGRAY);
 
    // <10 Ms
    wrch(60, 3, ms10, sizeof(ms10), LIGHTGRAY);
 
    // <50 Ms
    wrch(60, 4, ms50, sizeof(ms50), LIGHTGRAY);
 
    // <150 Ms
    wrch(60, 5, squ, 1, LIGHTGREEN);
    wrch(61, 5, ms150, sizeof(ms150), LIGHTGRAY);
 
    // <500 Ms
    wrch(60, 6, squ, 1, LIGHTRED);
    wrch(61, 6, ms500, sizeof(ms500), LIGHTGRAY);
 
    // >500 Ms
    wrch(60, 7, squ, 1, YELLOW);
    wrch(61, 7, ms500_2, sizeof(ms500_2), LIGHTGRAY);
 
    while(DiskSize>0)
    {
        // Засекаю время
        StartSeconds=appSeconds();
 
        // Читаю сектор в буфер
        ReadFile(hDevice,buf,BUFFSIZE,&dwBytes,NULL);
 
        // Устанавливаю позицию - назад, на размер буфера
        SetFilePointer(hDevice,lDistanceToMove,NULL,FILE_BEGIN);
 
        // Записываю
        WriteFile(hDevice,buf,BUFFSIZE,&dw,0);
 
        // Вычисляю время
        Total=appSeconds() - StartSeconds;
 
        // Устанавливаю позицию - вперед, на размер буфера
        lDistanceToMove+=dwBytes;
        SetFilePointer(hDevice,lDistanceToMove,NULL,FILE_BEGIN);
 
        DiskSize-=dwBytes;
 
        status=(int)Total;
        //status=GetStatus();
 
        if(status<3)
        status=3;
        else if(status<10)
        status=10;
        else if(status<50)
        status=50;
        else if(status<150)
        status=150;
        else if(status<500)
        status=500;
        else
        status=999;
 
        switch(status)
        {
        case 3:
            wrch(col, row, B0, 1, LIGHTGRAY);
            break;
        case 10:
            wrch(col, row, B1, 1, LIGHTGRAY);
            break;
        case 50:
            wrch(col, row, B2, 1, LIGHTGRAY);
            break;
        case 150:
            wrch(col, row, squ, 1, LIGHTGREEN);
            break;
        case 500:
            wrch(col, row, squ, 1, LIGHTRED);
            break;
        case 999:
            wrch(col, row, squ, 1, YELLOW);
            break;
        default:
            wrch(col, row, squ, 1, LIGHTGRAY);
        }
 
        ++col;
        if(MAX_COLUMNS==col)
        {
            col=0;
            ++row;
        }
 
        if(MAX_ROWS==row)
        {
            for(int x=2;x<MAX_ROWS;++x)
            {
                for(int i=0;i<MAX_COLUMNS;++i)
                wrch(i, x, space, 1, LIGHTGRAY);
            }
            row=2;
        }
    }
 
    CloseHandle(hDevice);
 
    wrch(0, 23, (unsigned char*)"---[ Done ]---", 14, WHITE);
    system("pause>nul");
}
 
DOUBLE appSeconds()
{
    static DWORD InitialTime=timeGetTime();
    static DOUBLE TimeCounter=0.0;
    DWORD NewTime=timeGetTime();
    TimeCounter+=(NewTime-InitialTime)*(1./1000.);
    InitialTime=NewTime;
    return TimeCounter;
}
 
void wrch(int x, int y, unsigned char* ch, int n, int clr)
{
    DWORD r;
    CONSOLE_SCREEN_BUFFER_INFO i;
    static HANDLE h;
    if(!h) h=GetStdHandle(STD_OUTPUT_HANDLE);
    GetConsoleScreenBufferInfo(h,&i);
    i.dwCursorPosition.X=x;
    i.dwCursorPosition.Y=y;
    WriteConsoleOutputCharacter(h,(char*)ch,n,i.dwCursorPosition,&r);
    FillConsoleOutputAttribute(h,clr,n,i.dwCursorPosition,&r);
}
 
/*
int GetStatus()
{
    // This function simulator (функция симулятор ответа-отклика)
    srand((unsigned)time(NULL));
    int n=rand() % 6;
    return n;
}
*/
 
////////////////////////////////////////////////////////////////////////////////
// <<eof>> main.cpp
////////////////////////////////////////////////////////////////////////////////