www.pudn.com > uformat_sourcecode.rar > unformat.cpp
/* // Program: Free Unformat // Version: 0.8 // Written By: Brian E. Reifsnyder // Copyright 1999 under the terms of the GNU GPL by Brian E. Reifsnyder // // Note: This program is free and is without a warranty of any kind. // */ /* ///////////////////////////////////////////////////////////////////////////// // INCLUDES ///////////////////////////////////////////////////////////////////////////// */ #include#include #include #include #include /* ///////////////////////////////////////////////////////////////////////////// // DEFINES ///////////////////////////////////////////////////////////////////////////// */ #define FOUND 1 #define LIST 1 #define TRUE 1 #define FALSE 0 #define NULL 0 #define PERCENTAGE 1 #define PRIMARY 0 #define EXTENDED 1 #define HARD 0 #define FLOPPY 1 #define FAT12 0 #define FAT16 1 #define FAT32 2 /* ///////////////////////////////////////////////////////////////////////////// // GLOBAL VARIABLES ///////////////////////////////////////////////////////////////////////////// */ int list_file_and_directory_names = 0; int print_output = 0; int test = 0; int unformat_without_mirror_file = 0; long sectors_per_fat; /* Physical Drive Parameters */ int physical_drive; int logical_drive; unsigned long logical_sector_offset; long total_cylinders; long total_heads; long total_sectors; long floppy_drive_type; int drive_type; int media_descriptor; /* Logical drive information */ long sectors_in_root_dir; int type_of_fat; unsigned long number_of_logical_sectors_on_drive; long number_of_root_directory_entries; /* Extracted cylinder & sector from partition table */ unsigned long g_cylinder; unsigned long g_sector; /* Partition Information */ int numeric_partition_type[24]; unsigned long starting_cylinder[24]; unsigned long starting_head[24]; unsigned long starting_sector[24]; unsigned long ending_cylinder[24]; unsigned long ending_head[24]; unsigned long ending_sector[24]; int relative_sectors_1[24]; int relative_sectors_2[24]; int relative_sectors_3[24]; int relative_sectors_4[24]; int partition_size_1[24]; int partition_size_2[24]; int partition_size_3[24]; int partition_size_4[24]; unsigned long partition_size[24]; int number_of_partitions; /* "Logical Drive to Format" translation information */ int physical_drive_number; unsigned long partition_starting_cylinder; unsigned long partition_starting_head; unsigned long partition_starting_sector; unsigned long partition_ending_cylinder; unsigned long partition_ending_head; unsigned long partition_ending_sector; unsigned long drive_maximum_cylinders; unsigned long drive_maximum_heads; unsigned long drive_maximum_sectors; unsigned long total_logical_sectors; unsigned long total_physical_sectors; int number_of_sectors_per_cluster; int partition_on_hard_disk; /* Translated values from "void Convert_Logical_To_Physical" */ unsigned long translated_head; unsigned long translated_cylinder; unsigned long translated_sector; /* Misc variables */ unsigned long integer1; unsigned long integer2; unsigned long integer3; unsigned long integer4; /* Buffers */ unsigned char mirror_map[5120]; unsigned char control_buffer[512]; unsigned char sector_buffer[512]; /* ///////////////////////////////////////////////////////////////////////////// // PROTOTYPES ///////////////////////////////////////////////////////////////////////////// */ int Compare_Sector_Buffers(); unsigned long Decimal_Number(unsigned long hex1, unsigned long hex2, unsigned long hex3, unsigned long hex4); void Copy_Sector_Into_Control_Buffer(); void Display_Help_Screen(); void List_Names(); void Read_Mirror_Map(); void Restore_Partition_Tables(int list); void Unformat_Drive(); void Verify_Drive_Mirror(); ////////////// void Clear_Sector_Buffer(); void Convert_Huge_To_Integers(unsigned long number); void Convert_Logical_To_Physical(unsigned long sector); void Extract_Cylinder_and_Sector(unsigned long hex1, unsigned long hex2); void Get_Drive_Parameters(); void Get_Physical_Floppy_Drive_Parameters(); void Get_Physical_Hard_Drive_Parameters(); void Read_Partition_Table(); void Read_Physical_Sector(int drive, int head, long cyl, int sector); void Read_Sector(unsigned long sector); void Reset_Drive(); void Write_Physical_Sector(int drive, int head, long cyl, int sector); void Write_Sector(unsigned long sector); /* ///////////////////////////////////////////////////////////////////////////// // FUNCTIONS ///////////////////////////////////////////////////////////////////////////// */ /* Clear Sector Buffer */ void Clear_Sector_Buffer() { long loop=0; do { sector_buffer[loop]=0; loop++; }while(loop<512); } /* Convert a logical sector to a physical drive location */ void Convert_Logical_To_Physical(unsigned long sector) { unsigned long remaining; if(drive_type==HARD) sector=sector+logical_sector_offset; translated_cylinder=sector/(total_sectors*(total_heads+1)); remaining=sector % (total_sectors*(total_heads+1)); translated_head=remaining/(total_sectors); translated_sector=remaining % (total_sectors); translated_sector++; } /* Compare Sector Buffers ///////////// */ int Compare_Sector_Buffers() { int answer=0; int compare=0; int loop = 0; do { compare=control_buffer[loop]-sector_buffer[loop]; if(compare!=0) answer = 1; loop++; } while(loop<512); return(answer); } /* Copy sector into control buffer //// */ void Copy_Sector_Into_Control_Buffer() { int loop=0; do { control_buffer[loop]=sector_buffer[loop]; loop++; } while(loop<=512); } /* Convert Hexidecimal Number to a Decimal Number */ unsigned long Decimal_Number(unsigned long hex1, unsigned long hex2, unsigned long hex3, unsigned long hex4) { return((hex1) + (hex2*256) + (hex3*65536) + (hex4*16777216)); } /* Extract Cylinder & Sector */ void Extract_Cylinder_and_Sector(unsigned long hex1, unsigned long hex2) { unsigned long cylinder_and_sector = ( (256*hex2) + hex1 ); g_sector = cylinder_and_sector % 64; g_cylinder = ( ( (cylinder_and_sector*4) & 768) + (cylinder_and_sector /256) ); } /* Get Drive Parameters */ /* The physical drive parameters are necessary to allow this program */ /* to bypass the DOS interrupts. */ void Get_Drive_Parameters() { int drives_found_flag; long hard_disk_installed[8]; int increment_heads=FALSE; int logical_drive_found=FALSE; int partition_number_of_logical_drive; int pointer=0; int possible_logical_drive; int possible_physical_hard_disk; int sub_pointer=0; int result; /* Brief partition table variables */ long partition_type_table[8][26]; long maximum_partition_assigned[8]; if(drive_type==FLOPPY) { physical_drive=logical_drive; Get_Physical_Floppy_Drive_Parameters(); partition_starting_cylinder=0; partition_starting_head=0; partition_starting_sector=1; partition_ending_cylinder=total_cylinders; partition_ending_head=total_heads; partition_ending_sector=total_sectors; drive_maximum_cylinders=total_cylinders; drive_maximum_heads=1; drive_maximum_sectors=total_sectors; total_logical_sectors=(total_cylinders+1)*(total_heads+1)*total_sectors; total_physical_sectors=total_logical_sectors; number_of_sectors_per_cluster=1; } else { /* Get availability of physical hard drives and */ /* assemble a brief partition table. */ /* Initialize partition_type_table */ pointer=0; do { partition_type_table[0][pointer]=0; partition_type_table[1][pointer]=0; partition_type_table[2][pointer]=0; partition_type_table[3][pointer]=0; partition_type_table[4][pointer]=0; partition_type_table[5][pointer]=0; partition_type_table[6][pointer]=0; partition_type_table[7][pointer]=0; pointer++; }while(pointer<=26); /* Initialize maximum_partition_assigned */ maximum_partition_assigned[0]=0; maximum_partition_assigned[1]=0; maximum_partition_assigned[2]=0; maximum_partition_assigned[3]=0; maximum_partition_assigned[4]=0; maximum_partition_assigned[5]=0; maximum_partition_assigned[6]=0; maximum_partition_assigned[7]=0; pointer=128; drives_found_flag=FALSE; do { result=biosdisk(2, pointer, 0, 0, 1, 1, sector_buffer); if(result==0) { drives_found_flag=TRUE; hard_disk_installed[pointer-128]=TRUE; physical_drive=pointer; Read_Partition_Table(); sub_pointer=0; do { partition_type_table[pointer-128][sub_pointer]=numeric_partition_type[sub_pointer]; sub_pointer++; }while(sub_pointer<=number_of_partitions); maximum_partition_assigned[pointer-128]=number_of_partitions; } else hard_disk_installed[pointer-128]=FALSE; pointer++; }while(pointer<136); /* If there aren't any physical hard drives available, exit program */ if(drives_found_flag==FALSE) { printf("\nNo hard disks found...operation terminated.\n"); exit(4); } /* Determine on which physical hard drive the logical drive is */ /* and on which partition it is located. */ /* Check on primary partitions */ possible_logical_drive=1; possible_physical_hard_disk=128; do { if(hard_disk_installed[possible_physical_hard_disk-128]==TRUE) { pointer=0; do { if( (partition_type_table[possible_physical_hard_disk-128][pointer]==0x01) || (partition_type_table[possible_physical_hard_disk-128][pointer]==0x04) || (partition_type_table[possible_physical_hard_disk-128][pointer]==0x06) ) { possible_logical_drive++; if(logical_drive==possible_logical_drive) { physical_drive=possible_physical_hard_disk; partition_number_of_logical_drive=pointer; logical_drive_found=TRUE; } } pointer++; }while(pointer<4); } possible_physical_hard_disk++; }while(possible_physical_hard_disk<136); /* Check on extended partitions */ possible_physical_hard_disk=128; if(logical_drive_found==FALSE) { do { if( (hard_disk_installed[possible_physical_hard_disk-128]==TRUE) && (maximum_partition_assigned[possible_physical_hard_disk-128]>=4) ) { pointer=4; do { if( (partition_type_table[possible_physical_hard_disk-128][pointer]==0x01) || (partition_type_table[possible_physical_hard_disk-128][pointer]==0x04) || (partition_type_table[possible_physical_hard_disk-128][pointer]==0x06) ) { possible_logical_drive++; if(logical_drive==possible_logical_drive) { physical_drive=possible_physical_hard_disk; partition_number_of_logical_drive=pointer; increment_heads=TRUE; logical_drive_found=TRUE; } } pointer++; }while(pointer<=maximum_partition_assigned[possible_physical_hard_disk-128]); } possible_physical_hard_disk++; }while(possible_physical_hard_disk<136); } /* Get a full partition table listing for that drive */ if(logical_drive_found==TRUE) { Get_Physical_Hard_Drive_Parameters(); Read_Partition_Table(); } else { printf("\nDrive letter entered is out of range...operation terminated.\n"); exit(4); } /* Load physical partition information */ partition_starting_cylinder=starting_cylinder[partition_number_of_logical_drive]; partition_starting_head=starting_head[partition_number_of_logical_drive]; partition_starting_sector=starting_sector[partition_number_of_logical_drive]; partition_ending_cylinder=ending_cylinder[partition_number_of_logical_drive]; partition_ending_head=ending_head[partition_number_of_logical_drive]; partition_ending_sector=ending_sector[partition_number_of_logical_drive]; drive_maximum_cylinders=ending_cylinder[partition_number_of_logical_drive]; drive_maximum_heads=total_heads; drive_maximum_sectors=total_sectors; total_logical_sectors=((partition_ending_cylinder-partition_starting_cylinder)+1)*(total_heads+1)*total_sectors; total_physical_sectors=total_logical_sectors; logical_sector_offset=((partition_starting_cylinder)*(total_heads+1)*(total_sectors)); if(logical_sector_offset==0) logical_sector_offset=(partition_starting_head)*(total_sectors); if(increment_heads==TRUE) logical_sector_offset=logical_sector_offset+total_sectors; /* Compute cluster size */ unsigned long size=(total_logical_sectors*512)/1000000; /* Sectors per cluster conversion table */ if (size<=32767) number_of_sectors_per_cluster=64; if (size<=16383) number_of_sectors_per_cluster=32; if (size<=8191) number_of_sectors_per_cluster=16; /* May be illegal cluster sizes if (size<=256) number_of_sectors_per_cluster=8; if (size<=128) number_of_sectors_per_cluster=4; */ } } /* Get Physical Floppy Drive Parameters */ void Get_Physical_Floppy_Drive_Parameters() { asm{ mov ah, 0x08 mov dl, BYTE PTR physical_drive int 0x013 mov BYTE PTR total_sectors, cl mov BYTE PTR total_cylinders, ch mov BYTE PTR total_heads, dh mov BYTE PTR floppy_drive_type, bl } } /* Get Physical Hard Drive Parameters */ void Get_Physical_Hard_Drive_Parameters() { asm{ mov ah, 0x08 mov dl, BYTE PTR physical_drive int 0x13 mov bl,cl and bl,00111111B mov BYTE PTR total_sectors, bl mov bl,cl mov cl,ch shr bl,1 shr bl,1 shr bl,1 shr bl,1 shr bl,1 shr bl,1 mov ch,bl mov WORD PTR total_cylinders, cx mov BYTE PTR total_heads, dh } } /* List File & Directory Names //////// */ void List_Names() { int loop=0; int sub_loop=0; char file_or_directory [12]; file_or_directory [8] = 46; do { sub_loop = 0; do { file_or_directory[sub_loop]=sector_buffer[(loop+sub_loop)]; sub_loop++; } while(sub_loop <=7); sub_loop++; do { file_or_directory[sub_loop]=sector_buffer[(loop+sub_loop-1)]; sub_loop++; } while(sub_loop <=11); if( (file_or_directory[0]>=48) && (file_or_directory[0]<=122) ) { printf("\n%.12s",file_or_directory); } loop = loop + 32; } while(loop <=480); } /* Help Routine ////////////////////// */ void Display_Help_Screen() { printf("\nUnformat Version 0.8 Restores a disk that has been formatted.\n\n"); printf("Syntax:\n\n"); printf("UNFORMAT drive: [/J]\n"); printf("UNFORMAT drive: [/U] [/L] [/TEST] [/P]\n"); printf("UNFORMAT /PARTN [/L]\n"); printf("UNFORMAT /?\n\n"); printf(" drive: Drive letter to unformat.\n"); printf(" /J Verifies that the drive mirror files is synchronized with the disk.\n"); printf(" /U * Unformats without using MIRROR files.\n"); printf(" /L Lists all files and directories found, or, when used with the\n"); printf(" /PART switch, displays current partition tables.\n"); printf(" /TEST * Displays information but does not write changes to disk.\n"); printf(" /P * Sends output messages to LPT1.\n"); printf(" /PARTN Restores disk partition tables.\n\n"); printf(" /? Displays this help screen.\n"); printf("This program is copyright 1998 by Brian E. Reifsnyder under the terms of\n"); printf("GNU General Public License and is without warranty of any kind.\n"); printf("\n* Indicates functions not yet available.\n"); } /* Read Partition Table */ void Read_Partition_Table() { long index=0x1be; int exiting_primary=TRUE; int extended=FALSE; int partition_designation=PRIMARY; int pointer=0; int record_extended_info_flag=FALSE; int done_flag=FALSE; unsigned long extended_cylinder; unsigned long extended_head; unsigned long extended_sector; Read_Physical_Sector(physical_drive,0,0,1); do{ if(pointer==4) partition_designation=EXTENDED; if((pointer>=4) && (extended==TRUE)) { Read_Physical_Sector(physical_drive,extended_head,extended_cylinder,extended_sector); extended=FALSE; index=0x1be; if(exiting_primary==FALSE) { pointer--; } else { exiting_primary=FALSE; } } /* Determine Partition Type */ numeric_partition_type[pointer]=sector_buffer[index+4]; if(sector_buffer[index+4]==0x00) { if(partition_designation==EXTENDED) { number_of_partitions=pointer; done_flag=TRUE; } } if(sector_buffer[index+4]==0x05) { extended=TRUE; record_extended_info_flag=TRUE; } starting_head[pointer] = sector_buffer[index+1]; ending_head[pointer] = sector_buffer[index+5]; partition_size[pointer]=Decimal_Number(sector_buffer[index+12],sector_buffer[index+13],sector_buffer[index+14],sector_buffer[index+15])/2000; Extract_Cylinder_and_Sector(sector_buffer[index+2],sector_buffer[index+3]); starting_cylinder[pointer]=g_cylinder; starting_sector[pointer]=g_sector; if((extended==TRUE) && (record_extended_info_flag==TRUE)) { extended_cylinder=starting_cylinder[pointer]; extended_head=starting_head[pointer]; extended_sector=starting_sector[pointer]; record_extended_info_flag=FALSE; } Extract_Cylinder_and_Sector(sector_buffer[index+6],sector_buffer[index+7]); ending_cylinder[pointer]=g_cylinder; ending_sector[pointer]=g_sector; partition_size_1[pointer]=sector_buffer[index+12]; partition_size_2[pointer]=sector_buffer[index+13]; partition_size_3[pointer]=sector_buffer[index+14]; partition_size_4[pointer]=sector_buffer[index+15]; relative_sectors_1[pointer]=sector_buffer[index+8]; relative_sectors_2[pointer]=sector_buffer[index+9]; relative_sectors_3[pointer]=sector_buffer[index+10]; relative_sectors_4[pointer]=sector_buffer[index+11]; pointer++; number_of_partitions=pointer-1; if((extended==FALSE) && (pointer==4)) { number_of_partitions=4; done_flag=TRUE; } index=index + 16; } while(done_flag==FALSE); } /* Read Physical Sector */ void Read_Physical_Sector(int drive, int head, long cyl, int sector) { int result; result=biosdisk(2, drive, head, cyl, sector, 1, sector_buffer); if (result!=0) { printf("\nRead error...operation terminated.\n"); exit(4); } } /* Read Sector From Disk */ void Read_Sector(unsigned long sector) { Convert_Logical_To_Physical(sector); printf("Cylinder: %5i ",translated_cylinder); printf("Head: %2i \n",translated_head); /* printf("Sector: %i \n",translated_sector); */ /* Re-position cursor back to the beginning of the line */ asm{ /* Get current video display mode */ mov ah,0x0f int 0x10 /* Get cursor position */ mov ah,0x03 int 0x10 /* Set cursor position to beginning of line */ mov ah,0x02 sub dh,1 int 0x10 } Read_Physical_Sector(physical_drive,translated_head,translated_cylinder,translated_sector); } /* Read Mirror Map Into Buffer //////// */ void Read_Mirror_Map() { int flag = 0; long loop; long mirror_map_pointer; long index; long subloop; long current_sector; long mirror_map_start_sector; long source_sector; long destination_sector; printf("\n\nSearching for drive mirror...\n"); /*Find "pointer sector" at end of drive */ current_sector=total_logical_sectors-200; if(current_sector<0) { current_sector=0; } /*If drive is a floppy drive, change the following: */ if(drive_type==FLOPPY) { current_sector=total_logical_sectors-10; total_logical_sectors--; } do { Read_Sector(current_sector); if((65==sector_buffer[4])&&(77==sector_buffer[5])&&(83==sector_buffer[6])&&(69==sector_buffer[7])) { mirror_map_start_sector=Decimal_Number(sector_buffer[0],sector_buffer[1],sector_buffer[2],sector_buffer[3]); flag=FOUND; } current_sector++; } while((current_sector<=total_logical_sectors) || (flag!=FOUND)); loop=0; if(FOUND==flag) { /*Read Mirror Map into buffer */ printf("\n\nLoading drive mirror...\n"); do { Read_Sector(mirror_map_start_sector+loop); subloop=0; do { mirror_map[subloop+(loop*512)]=sector_buffer[subloop]; subloop++; }while(subloop<512); loop++; }while(loop<=10); } else { printf("\nThe sector that points to the drive mirror has not been found.\n"); printf("Operation Terminated.\n"); exit(1); } } /* Reset drive controller */ void Reset_Drive() { asm{ mov ah,0 mov dl,BYTE PTR physical_drive int 0x13 mov ah,0 mov dl,BYTE PTR physical_drive int 0x13 } } /* Restore Partition Tables /////////// */ void Restore_Partition_Tables(int list) { if(list!=LIST) { /* Re-create the partition tables on the hard disks from the /* a:partnsav.fil. */ /* Map of the PARTNSAV.FIL for FreeDOS: (I do not plan on using an MS-DOS compatible file.) offset:00 FreeDOS partitio n mirror file offset:32-127 reserved for future expansion offset:128(drive#) 129(lb offset) 130(mb offset) 131(lb dest cyl) 132(mb dest cyl) 133(lb dest head) 134(mb dest head) 135(dest sect.) . . . offset:1024 stored sector offset:1536 stored sector offset:2048 stored sector . . . */ long index=0; FILE *file_pointer; unsigned char partition_table_map[1024]; int drive_number; unsigned long destination_cylinder; unsigned long destination_head; unsigned long destination_sector; /* Clear partition_table_map[] */ index=0; do { partition_table_map[index]=0; index++; }while(index<=1023); /* Load the map of the PARTNSAV.FIL file */ index=0; file_pointer=fopen("A:\\PARTNSAV.FIL","rb"); if(file_pointer==NULL) { printf("\nError opening \"A:\\PARTNSAV.FIL\"...Operation terminated.\n"); exit(1); } /* Read the map from the PARTNSAV.FIL file */ test=fread(&partition_table_map,1024,1,file_pointer); if(test==0) { printf("\nError reading \"A:\\PARTNSAV.FIL\"...Operation terminated.\n"); exit(1); } /* Write the partitions to the hard disk(s) */ index=128; do { /* Read the drive number */ drive_number=partition_table_map[index+0]; /* Get the destination cylinder */ destination_cylinder=Decimal_Number(partition_table_map[index+3],partition_table_map[index+4],0,0); /* Get the destination head */ destination_head=Decimal_Number(partition_table_map[index+5],partition_table_map[index+6],0,0); /* Get the destination sector */ destination_sector=partition_table_map[index+7]; /* Read the partition sector from the partnsav.fil */ fread(sector_buffer,512,1,file_pointer); /* Write the partition sector to the hard disk */ Write_Physical_Sector(drive_number,destination_head,destination_cylinder,destination_sector); index=index+8; }while(0!=partition_table_map[index]); fclose(file_pointer); } else { /* List all of the partition tables */ printf("\nThis feature is not implemented at this time.\n"); } exit(0); } /* Unformat Drive ///////////////////// */ void Unformat_Drive() { int loop; long mirror_map_pointer; long index; long current_sector; long mirror_map_start_sector; long source_sector; long destination_sector; Read_Mirror_Map(); printf("\n\nUnformatting drive...\n"); /*Re-create the boot sector */ destination_sector=Decimal_Number(mirror_map[84],mirror_map[85],mirror_map[86],mirror_map[87]); source_sector=Decimal_Number(mirror_map[88],mirror_map[89],mirror_map[90],mirror_map[91]); Read_Sector(source_sector); Write_Sector(destination_sector); /* Get the size of the FAT tables from the boot sector */ Read_Sector(0); sectors_per_fat=Decimal_Number(sector_buffer[22],sector_buffer[23],0,0); /*Re-create the FAT tables */ mirror_map_pointer = 92; index=1; do { destination_sector=Decimal_Number(mirror_map[mirror_map_pointer],mirror_map[(mirror_map_pointer+1)],mirror_map[(mirror_map_pointer+2)],mirror_map[(mirror_map_pointer+3)]); source_sector=Decimal_Number(mirror_map[(mirror_map_pointer+4)],mirror_map[(mirror_map_pointer+5)],mirror_map[(mirror_map_pointer+6)],mirror_map[(mirror_map_pointer+7)]); Read_Sector(source_sector); Write_Sector(destination_sector); Write_Sector(destination_sector+sectors_per_fat); mirror_map_pointer=mirror_map_pointer + 8; index++; } while(index<=sectors_per_fat); /*Re-create the Root Directory */ loop=1; /*If drive is a floppy drive, change the loop for a smaller root dir*/ if(drive_type==FLOPPY) loop=18; do { destination_sector=Decimal_Number(mirror_map[mirror_map_pointer],mirror_map[(mirror_map_pointer+1)],mirror_map[(mirror_map_pointer+2)],mirror_map[(mirror_map_pointer+3)]); source_sector=Decimal_Number(mirror_map[(mirror_map_pointer+4)],mirror_map[(mirror_map_pointer+5)],mirror_map[(mirror_map_pointer+6)],mirror_map[(mirror_map_pointer+7)]); Read_Sector(source_sector); /* If user wants the file and directory names listed, list them. */ if(1==list_file_and_directory_names) List_Names(); Write_Sector(destination_sector); mirror_map_pointer=mirror_map_pointer + 8; loop++; } while(loop<=31); printf("\n\nUnformat operation complete!\n"); } /* Verify Drive Mirror //////////////// */ void Verify_Drive_Mirror() { long mirrored_sector; long system_sector; int loop; long mirror_map_pointer; long index; long current_sector; long mirror_map_start_sector; Read_Mirror_Map(); printf("\n\nComparing drive mirror with file system...\n"); /*Compare the boot sector */ system_sector=Decimal_Number(mirror_map[84],mirror_map[85],mirror_map[86],mirror_map[87]); mirrored_sector=Decimal_Number(mirror_map[88],mirror_map[89],mirror_map[90],mirror_map[91]); Read_Sector(system_sector); Copy_Sector_Into_Control_Buffer(); Read_Sector(mirrored_sector); if(Compare_Sector_Buffers()!=0) { printf("\n\nVerification failed at boot sector...operation terminated.\n\n"); exit(1); } /*Compare the FAT tables */ mirror_map_pointer = 92; index=1; do { system_sector=Decimal_Number(mirror_map[mirror_map_pointer],mirror_map[(mirror_map_pointer+1)],mirror_map[(mirror_map_pointer+2)],mirror_map[(mirror_map_pointer+3)]); mirrored_sector=Decimal_Number(mirror_map[(mirror_map_pointer+4)],mirror_map[(mirror_map_pointer+5)],mirror_map[(mirror_map_pointer+6)],mirror_map[(mirror_map_pointer+7)]); Read_Sector(system_sector); Copy_Sector_Into_Control_Buffer(); Read_Sector(mirrored_sector); if(Compare_Sector_Buffers()!=0) { printf("\n\nVerification failed on 1st FAT table...operation terminated.\n\n"); exit(1); } Read_Sector(system_sector+sectors_per_fat); if(Compare_Sector_Buffers()!=0) { printf("\n\nVerification failed on 2nd FAT table...operation terminated.\n\n"); exit(1); } mirror_map_pointer=mirror_map_pointer + 8; index++; } while(index<=sectors_per_fat); /*Compare the Root Directory */ loop=1; /*If drive is a floppy drive, change the loop for a smaller root dir*/ if( (0==logical_drive) || (1==logical_drive) ) loop=18; do { system_sector=Decimal_Number(mirror_map[mirror_map_pointer],mirror_map[(mirror_map_pointer+1)],mirror_map[(mirror_map_pointer+2)],mirror_map[(mirror_map_pointer+3)]); mirrored_sector=Decimal_Number(mirror_map[(mirror_map_pointer+4)],mirror_map[(mirror_map_pointer+5)],mirror_map[(mirror_map_pointer+6)],mirror_map[(mirror_map_pointer+7)]); Read_Sector(system_sector); Copy_Sector_Into_Control_Buffer(); Read_Sector(mirrored_sector); if(Compare_Sector_Buffers()!=0) { printf("\n\nVerification failed at root directory...operation terminated.\n\n"); exit(1); } mirror_map_pointer=mirror_map_pointer + 8; loop++; } while(loop<=31); printf("\n\nMirror image has been verified.\n\n"); exit(0); } /* Write Physical Sector */ void Write_Physical_Sector(int drive, int head, long cyl, int sector) { int result; result=biosdisk(3, drive, head, cyl, sector, 1, sector_buffer); if (result!=0) { printf("\nDisk write error...operation terminated.\n"); exit(4); } } /* Write Sector To Disk */ void Write_Sector(unsigned long sector) { Convert_Logical_To_Physical(sector); printf("Cylinder: %5i ",translated_cylinder); printf("Head: %2i \n",translated_head); /* printf("Sector: %i \n",translated_sector); */ /* Re-position cursor back to the beginning of the line */ asm{ /* Get current video display mode */ mov ah,0x0f int 0x10 /* Get cursor position */ mov ah,0x03 int 0x10 /* Set cursor position to beginning of line */ mov ah,0x02 sub dh,1 int 0x10 } Write_Physical_Sector(physical_drive,translated_head,translated_cylinder,translated_sector); } /* ///////////////////////////////////////////////////////////////////////////// // MAIN ROUTINE ///////////////////////////////////////////////////////////////////////////// */ void main(int argc, char *argv[]) { int true=1; /* if UNFORMAT is typed without any options */ if(argc==1) { Display_Help_Screen(); exit(1); } /* if UNFORMAT is typed with more than one option and // the first option is "/?" or "/PARTN" or "/partn" */ if(argc>=2) { /* if "UNFORMAT /?" is entered */ true=strcmp("/?",argv[1]); if(0==true) { Display_Help_Screen(); exit(0); } /* if "UNFORMAT /PARTN" or "UNFORMAT /partn" is entered */ if(0==stricmp("/PARTN",argv[1])) { if(argc==3) { /*if "UNFORMAT /PARTN /L" is entered */ if(0==stricmp("/L",argv[2])) { Restore_Partition_Tables(LIST); exit(0); } printf("\nSyntax error, type \"UNFORMAT /?\" for help.\n"); exit(1); } else { Restore_Partition_Tables(FALSE); exit(0); } } } /*if UNFORMAT is typed with a drive letter */ if(argc>=2) { char drive_letter[1]; char *input; logical_drive=argv[1] [0]; if(logical_drive>=97) logical_drive = logical_drive - 97; if(logical_drive>=65) logical_drive = logical_drive - 65; if( (logical_drive<0) || (logical_drive> 25) ) { printf("\nSyntax error, type \"UNFORMAT /?\" for help.\n"); exit(1); } drive_letter[0] = logical_drive+65; drive_letter[1] = 58; if(logical_drive>=2) drive_type=HARD; else drive_type=FLOPPY; Get_Drive_Parameters(); true=1; true=stricmp("/j",argv[2]); if(0==true) Verify_Drive_Mirror(); true=0; if(0==true) { if(argc>=3) { int switch_to_test = (argc-1); do { true=1; true=stricmp("/u",argv[switch_to_test]); if(0==true) unformat_without_mirror_file = 1; true=1; true=stricmp("/l",argv[switch_to_test]); if(0==true) list_file_and_directory_names = 1; true=1; true=stricmp("/test",argv[switch_to_test]); if(0==true) test = 1; true=1; true=stricmp("/p",argv[switch_to_test]); if(0==true) print_output = 1; switch_to_test--; } while (switch_to_test>=2); } Unformat_Drive(); } } }