Hoofdstuk – 16
MEER SCHIJFHULPPROGRAMMA'S ONTWIKKELEN
Invoering
In dit hoofdstuk bespreken we hoe u MBR-, DBR-, FAT- en rootdirectory-informatie kunt gebruiken om hulpprogramma's te ontwikkelen waarmee u gegevens kunt beheren, de opslag kunt optimaliseren of veel schijfproblemen kunt oplossen.
Meestal zijn deze programma's een oplossing voor een specifiek probleem. In dit hoofdstuk worden enkele hulpprogramma's en de programmering ervan besproken.
Secties verbergen
Normaal gesproken wordt het hulpprogramma voor het verbergen van partities gebruikt door gebruikers die op hetzelfde computersysteem werken als de gebruikers. Als er veel gebruikers op één computer zitten, is de kans groot dat de gegevens van een andere gebruiker kunnen worden gelezen, gestolen of verwijderd.
In zo'n geval kan het zo zijn dat de gebruiker belangrijke gegevens of vertrouwelijke informatie op dezelfde computer heeft staan. Hij kan dan de partitie waarop deze gegevens zich bevinden, verbergen. Op die manier is de partitie niet toegankelijk voor het besturingssysteem en dus ook niet voor een andere gebruiker.
Wanneer de gebruiker aan het systeem wil werken, kan hij de sectie eenvoudig openen om weer toegang te krijgen tot de sectie. Meestal vinden dit soort gebeurtenissen plaats op beroepsopleidingen waar veel studenten computers gebruiken, maar ouderejaarsstudenten zich altijd zorgen maken over hun belangrijke gegevens of projectwerk. Net als bij gebrek aan kennis kan een nieuwe student zijn gegevens beschadigen of zelfs wissen.
Hoe wordt een sectie verborgen?
De volgende tabel toont de partitie-indeling in de MBR-partitietabel:
| Compenseren |
Betekenis |
Maat |
Beschrijving |
| 00U |
Opstarttype-indicatorbyte |
1 byte |
Als de byte 00H is, is de partitie inactief. Als de byte 80H is , is de partitie actief (of opstartbaar). |
| 01U |
Start sectienummer |
1 byte |
Beginpartitienummer in hexadecimaal |
| 02U |
Sector- en cilindernummer van het begin van de partitie |
2 bytes |
De 6 bits van de eerste byte vormen het startsectornummer en de combinatie van de resterende 2 bits (als de twee meest significante bits) en de 8 bits van de andere byte (de resterende 8 minst significante bits van het 10-bits nummer) vormen het startcilindernummer van de partitie. |
| 04U |
Bestandssysteemindicatorbyte |
1 byte |
Bestandssysteemindicatorbyte in hexadecimaal (voor een volledige lijst van partitie-indicatorbytes, zie het hoofdstuk "Logische benadering van schijven en besturingssystemen", eerder in dit boek besproken) |
| 05U |
Einde van sectiekopnummer |
1 byte |
Eindpartitienummer in hexadecimaal |
| 06U |
Sector- en cilindernummer aan het einde van de sectie |
2 bytes |
De 6 bits van de eerste byte vormen het uiteindelijke sectornummer en de combinatie van de resterende 2 bits (als de twee meest significante bits) en de 8 bits van de andere byte (de resterende 8 minst significante bits van het 10-bits nummer) vormen het uiteindelijke cilindernummer van de partitie. |
| 08U |
Absoluut sectornummer van het begin van de partitie |
4 bytes |
Aantal sectoren tussen MBR en eerste sector in partitie |
| 0H |
Absoluut sectornummer van het einde van de partitie |
4 bytes |
Aantal sectoren in sectie |
|
|
Totaal = 16 bytes |
|
Op offset 04H bevindt zich in elke partitie-invoer een bestandssysteemindicatorbyte. Deze indicatorbyte vertegenwoordigt het bestandssysteemtype van deze partitie. Als de waarde van deze byte verandert, verandert de sectie-identificatie.
De partitie-indicatorbytewaarde voor 'DOS 12-Bit FAT' is bijvoorbeeld 0x01. Als u deze waarde wijzigt naar 0x11, verandert de bestandssysteem-ID in de partitietabelvermelding in "Hidden DOS 12-Bit FAT" (voor een volledige lijst met partitie-indicatorbytes, zie het hoofdstuk "Logische benadering van schijven en besturingssystemen", dat eerder in dit boek is besproken).
De onderstaande tabel toont nog enkele voorbeelden van indicatorbytes voor bestandssystemen voor bepaalde partitietypen:
| Partitietype-indicatorbyte |
Beschrijving van het partitiebestandssysteem |
| 0x01 |
DOS 12-bits FAT |
| 0x11 |
Verborgen DOS 12-bits FAT |
| 0x04 |
DOS 16-bits FAT (<=32 MB) |
| 0x14 |
Verborgen DOS 16-bits FAT (<=32 MB) |
| 0x05 |
DOS uitgebreid |
| 0x15 |
Verborgen DOS uitgebreid |
| 0x06 |
DOS 16-bit groot (>32 MB) |
| 0x16 |
Verborgen DOS 16-bits Groot (>32 MB) |
| 0x07 |
NTFS |
| 0x17 |
Verborgen NTFS |
| 0x0B |
Windows FAT32 |
| 0x1B |
Verborgen Windows FAT32 |
| 0x0C |
Windows FAT32 (LBA) |
| 0x1C |
Verborgen Windows FAT32 (LBA) |
| 0x0E |
Windows FAT16 (LBA) |
| 0x1E |
Verborgen Windows FAT16 (LBA) |
| 0x0F |
Vensters uitgebreid |
| 0x1F |
Verborgen vensters uitgebreid |
Hier zien we dat de overeenkomstige verborgen partitie voor een bestandssysteem wordt gevonden door de waarde 0x10 toe te voegen aan de systeemindicatorbyte.
Hoewel het niet de harde en snelle regel is voor het verbergen van de partitie, werkt het zelfs voor de meeste bestandssystemen. De reden hiervoor is dat wanneer we de waarde van de partitie-indicatorbyte wijzigen, de identiteit van het bestandssysteem in de partitietabelinvoer wordt gewijzigd. En het komt zelden voor dat het nieuwe bestandssysteem ook door hetzelfde besturingssysteem wordt ondersteund.
Programma schrijven om partitie te verbergen
Het hierna gegeven programma wordt gebruikt om de partitie te verbergen met behulp van de partitie-invoer van die partitie uit de partitietabel van MBR. Als u andere logische partities in het uitgebreide volume wilt verbergen, moet u de uitgebreide MBR's benaderen.
De codering van het programma is als volgt:
/* Programma om de partitie te verbergen met behulp van de partitietabelinvoer van die partitie uit de MBR */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo;
int resultaat, verbergen;
int ik;
static char dbuf[512];/* Gegevensbuffer om de
Sectorinformatie */
clrscr();
dinfo.drive = 0x80; /* schijfnummer voor Eerste
Harde schijf */
dinfo.head = 0; /* schijfkopnummer */
dinfo.track = 0; /* tracknummer */
dinfo.sector = 1; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
/* Lees de eerste sector van de schijf */
resultaat = _bios_disk(_DISK_READ, &dinfo);
als ((resultaat & 0xff00) == 0)
{
printf("De partitiecodes van vier partitie-ingangen zijn,
0x%02x, 0x%02x, 0x%02x en 0x%02x.\n",
dbuf[450] & 0xff, dbuf[466] & 0xff,
dbuf[482] & 0xff, dbuf[498] & 0xff);
tekstkleur(15);
gotoxy(5,5);cprintf("Partitie-invoer in MBR is als
volgt:");
gotoxy(10,7); cprintf("1. "); showtype(dbuf[450] & 0xff);
gotoxy(10,8); cprintf("2. "); showtype(dbuf[466] & 0xff);
gotoxy(10,9); cprintf("3. "); showtype(dbuf[482] & 0xff);
gotoxy(10,10); cprintf("4. "); showtype(dbuf[498] & 0xff);
/* Haal de gebruikersinvoer op voor het verbergen van de partitie */
gotoxy(1,15);
printf("Voer het partitienummer in dat u wilt verbergen,
Of druk op een andere toets om af te sluiten... ");
tohide=getche();
schakelen(om te verbergen)
{
case '1': /* Verberg eerste partitie in partitietabel */
dbuf[450] = dbuf[450] +16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
case '2': /* Verberg tweede partitie in partitietabel */
dbuf[466] = dbuf[466]+16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
case '3': /* Verberg derde partitie in partitietabel */
dbuf[482] = dbuf[482] +16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
case '4': /* Verberg vierde partitie in partitietabel */
dbuf[498] = dbuf[498]+16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
standaard:
uitgang(0);
}
als ((resultaat & 0xff00) == 0)
{
printf("\n\nDe nieuwe partitiecodes van vier partities
De items zijn 0x%02x, 0x%02x, 0x%02x en 0x%02x.\n",
dbuf[450] & 0xff, dbuf[466] & 0xff,
dbuf[482] & 0xff, dbuf[498] & 0xff);
halen();
}
anders
{
printf("Kan de byte niet wijzigen, status = 0x%02x\n",
resultaat);
halen();
}
}
retourneer 0;
}
Opmerkingen over codering:
Het programma leest de indicatorbytes van het bestandssysteem van alle vier partitie-items in de partitietabel van MBR. De functie showtype( ) wordt gebruikt om de naam van het bestandssysteem te tonen voor de overeenkomstige waarde van de indicatorbyte van het bestandssysteem.
De gebruiker selecteert de partitie die hij wil verbergen in het menu dat op het scherm wordt weergegeven. Vervolgens wordt er 16 (0x10) toegevoegd aan de waarde van de bestandssysteemindicatorbyte van die partitie om de partitie te verbergen.
De codering van de functie showtype( ) is als volgt:
/* Functie om de naam van het bestandssysteem weer te geven dat overeenkomt met de waarde van de bestandssysteemindicatorbyte */
toontype(i)
{
schakelaar (i)
{
case 0x00 :cprintf("Leeg"); break;
geval 0x01 :cprintf("DOS 12-bits FAT"); break;
geval 0x02 :cprintf("XENIX-root"); onderbreking;
geval 0x03 :cprintf("XENIX usr"); onderbreking;
geval 0x04 :cprintf("DOS 16-bit <32M"); onderbreking;
geval 0x05 :cprintf("Uitgebreid"); break;
geval 0x06 :cprintf("DOS 16-bit >=32M"); onderbreking;
geval 0x07 :cprintf("OS/2 HPFS"); onderbreking;
geval 0x08 :cprintf("AIX"); onderbreking;
case 0x09 :cprintf("AIX opstartbaar"); break;
case 0xa :cprintf("OS/2 Boot Management"); break;
geval 0xb :cprintf("Win95/98/ME FAT32"); onderbreking;
geval 0xc :cprintf("Win95/98/ME FAT32 (LBA)"); onderbreking;
geval 0xd :cprintf("Win95 FAT16"); onderbreking;
geval 0xe :cprintf("Win95 FAT16 (LBA)"); onderbreking;
geval 0xf :cprintf("Win95 Uitgebreid"); break;
case 0x11 :cprintf("Verborgen FAT-12");break;
geval 0x12 :cprintf("Compaq Diagnostiek");break;
case 0x14 :cprintf("Verborgen FAT-16 (<32)");break;
case 0x15 :cprintf("Verborgen uitgebreid");break;
case 0x16 :cprintf("Verborgen FAT-16");break;
geval 0x17 :cprintf("NTFS"); break;
geval 0x40 :cprintf("Venix 80286"); onderbreking;
geval 0x51 :cprintf("Novell?"); onderbreking;
geval 0x52 :cprintf("Micropoort"); break;
geval 0x63 :cprintf("GNU HURD"); onderbreking;
geval 0x64 :
geval 0x65 :cprintf("Novell Netware"); onderbreking;
geval 0x75 :cprintf("PC/IX"); onderbreking;
case 0x80 :cprintf("Oude MINIX"); break;
geval 0x81 :cprintf("Linux/MINIX"); onderbreking;
geval 0x82 :cprintf("Linux-wissel"); break;
geval 0x83 :cprintf("Linux-native"); break;
geval 0x85 :cprintf("Linux Uitgebreid"); break;
geval 0x93 :cprintf("Amoebe"); break;
geval 0x94 :cprintf("Amoebe BBT"); break;
geval 0xa5 :cprintf("BSD/386"); onderbreking;
geval 0xa6 :cprintf("OpenBSD"); break;
geval 0xa7 :cprintf("NEXTSTEP"); onderbreking;
geval 0xb7 :cprintf("BSDI fs"); onderbreking;
geval 0xb8 :cprintf("BSDI-wissel"); onderbreking;
geval 0xc7 :cprintf("Syrinx"); onderbreking;
geval 0xdb :cprintf("CP/M"); onderbreking;
case 0xe1 :cprintf("DOS-toegang"); break;
geval 0xe3 :cprintf("DOS R/O"); onderbreking;
case 0xf2 :cprintf("DOS secundair"); break;
geval 0xff :cprintf("BBT"); break;
standaard :cprintf("ONBEKEND");
}
retourneer 0;
}
Programma schrijven om de partitie zichtbaar te maken
Het programma om de verborgen partitie zichtbaar te maken werkt precies het tegenovergestelde van het programma dat het programma verbergt. In dit programma trekken we 16 (0x10) af van de waarde van de bestandssysteemindicatorbyte van de verborgen partitie.
De codering van het programma is als volgt:
/* Programma om de partitie zichtbaar te maken die door het vorige programma verborgen is */
#include <bios.h>
#include <stdio.h>
int hoofd(leeg)
{
structuur diskinfo_t dinfo;
int resultaat, verbergen;
int ik;
static char dbuf[512];/* Gegevensbuffer */
clrscr();
dinfo.drive = 0x80; /* schijfnummer voor
Eerste harde schijf */
dinfo.head = 0; /* schijfkopnummer */
dinfo.track = 0; /* tracknummer */
dinfo.sector = 1; /* sectornummer */
dinfo.nsectors = 1; /* sectoraantal */
dinfo.buffer = dbuf; /* gegevensbuffer */
resultaat = _bios_disk(_DISK_READ, &dinfo);
als ((resultaat & 0xff00) == 0)
{
printf("De partitiecodes van vier partities
De items zijn 0x%02x, 0x%02x, 0x%02x en 0x%02x.\n",
dbuf[450] & 0xff, dbuf[466] & 0xff,
dbuf[482] & 0xff, dbuf[498] & 0xff);
tekstkleur(15);
gotoxy(5,5);
cprintf("Partitie-invoer in MBR is als volgt:");
gotoxy(10,7); cprintf("1. "); showtype(dbuf[450] & 0xff);
gotoxy(10,8); cprintf("2. "); showtype(dbuf[466] & 0xff);
gotoxy(10,9); cprintf("3. "); showtype(dbuf[482] & 0xff);
gotoxy(10,10); cprintf("4. "); showtype(dbuf[498] & 0xff);
/* Haal de Use-invoer op om de partitie zichtbaar te maken */
gotoxy(1,15);printf("Voer het partitienummer in, dat moet worden
zichtbaar maken, of druk op een andere toets om
Uitgang... ");
tohide=getche();
schakelen(om te verbergen)
{
/* Eerste partitie van partitietabel zichtbaar maken */
geval '1':
dbuf[450] = dbuf[450] -16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
/* Tweede partitie van partitietabel zichtbaar maken */
geval '2':
dbuf[466] = dbuf[466]-16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
/* Derde partitie van partitietabel zichtbaar maken */
geval '3':
dbuf[482] = dbuf[482] -16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
/* Maak de vierde partitie van de partitietabel zichtbaar */
geval '4':
dbuf[498] = dbuf[498]-16;
resultaat = _bios_disk(_DISK_WRITE, &dinfo);
pauze;
standaard:
uitgang(0);
}
als ((resultaat & 0xff00) == 0)
{
printf("\n\nDe nieuwe partitiecodes van vier partities
De items zijn 0x%02x, 0x%02x, 0x%02x en 0x%02x.\n",
dbuf[450] & 0xff, dbuf[466] & 0xff,
dbuf[482] & 0xff, dbuf[498] & 0xff);
halen();
}
anders
{
printf("Kan de byte niet wijzigen, status = 0x%02x\n",
resultaat);
halen();
}
}
retourneer 0;
}
Reacties op het programma
Wees voorzichtig bij het opgeven van het partitienummer om het zichtbaar te maken. Als het partitienummer per ongeluk verkeerd wordt ingevoerd, wordt de bestandssysteeminformatie van die partitie gewijzigd en kan de partitie ontoegankelijk worden. Het eerder besproken programma om de partities te verbergen, kan u echter helpen om de bestandssysteemindicatorbyte van die partitie te herstellen.
Programma schrijven om partitie te verwijderen
Het programma om partities te verwijderen wordt gebruikt voor probleemoplossing. Stel bijvoorbeeld dat u de FAT32-bestandssysteempartities op uw schijf had. Nu hebt u besloten om het LINUX-besturingssysteem tegelijkertijd op uw schijf te installeren.
Als er op welke manier dan ook een onderbreking is in de installatie van het besturingssysteem, in de fase waarin de wijzigingen werden aangebracht in de partitietabel van de MBR. In zulke gevallen is er een grote kans dat de partitie, waarin u het andere besturingssysteem zou installeren, ontoegankelijk wordt.
In dit geval wordt de schijfruimte van de verloren partitie nutteloos omdat deze ontoegankelijk is. Als we echter de partitie-informatie van die partitie op welke manier dan ook uit de partitietabel verwijderen, kunnen we deze ruimte weer bruikbaar maken met behulp van de FDISK-opdracht van DOS.
Het programma om de partitie-invoer uit de partitietabel van MBR te verwijderen is als volgt:
/* Programma om de tweede partitie-invoer uit de partitietabel van MBR te verwijderen */
# voeg <bios.h> toe
/* structuur om de partitie-invoer uit de partitietabel te lezen */
struct partitie
{
/* Actieve partitiebyte */
ongetekende char opstartbaar;
/* Starthoofd */
ongetekende char start_side;
/* combinatie van startsector en cilindernummer */
ongetekend int start_sec_cyl ;
/* Bestandssysteem Indicator Byte */
ongetekend char-onderdeeltype;
/* Eindkop */
ongetekende char end_side;
/* combinatie van startsector en cilindernummer */
ongetekend int end_sec_cyl ;
/* Relatief sectornummer */
ongetekend lang part_beg ;
/* Partitielengte in sectoren */
ongetekende lange plen;
} ;
/* Structuur om MBR te lezen/schrijven */
structuur onderdeel
{
/* IPL (Initiële Programma Lader) */
ongetekende char master_boot[446] ;
/* Partitietabel */
struct partitie pt[4] ;
/* Magisch getal */
int laatste twee ;
} ;
struct deel p;
leeg hoofd()
{
ongetekende int t1,t2;
clrscr();
biosdisk ( 2, 0x80, 0, 0, 1, 1, &p );
display(); /* toon de informatie van
Partitietabel */
halen();
p.pt[1].opstartbaar = 0;
p.pt[1].start_zijde = 0 ;
p.pt[1].start_sec_cyl = 0 ;
p.pt[1].parttype = 0;
p.pt[1].eind_zijde = 0;
p.pt[1].end_sec_cyl = 0;
p.pt[1].part_beg = 0;
p.pt[1].plen = 0;
printf("\n\n\n Na het verwijderen van de tweede partitie
Invoer uit MBR-partitietabel,");
printf("\n De partitietabel wordt gewijzigd als
Volgt: ");
/* Om informatie van de tweede partitie van de partitie te verwijderen
tabel van MBR Verwijder de schuine strepen uit de
biosdisk( ) functie. Niet achteloos gebruiken, Partitioneren
Informatie over de tweede partitie van de partitietabel zal
volledig worden gewist. */
////// biosdisk ( 3, 0x80, 0, 0, 1, 1, &p ) ;
display(); /* Geef de informatie van de partitie weer
tabel na wijziging */
halen();
}
Reacties op het programma:
Verwijder de commentaartekens voor de functie biosdisk (3, 0x80, 0, 0, 1, 1, &p) om de tweede partitie uit de partitietabel van MBR te verwijderen.
Om de partitie te verwijderen, worden alle parameters ervan ingesteld op 0 in de partitietabelinvoer in MBR. Onthoud altijd dat als u de uitgebreide partitie verwijdert, alle logische partities van die uitgebreide partitie ook ontoegankelijk worden.
De functie display( ) wordt gebruikt om de partitietabel van MBR weer te geven. De codering van de functie is als volgt:
/* Functie om partitietabel van MBR weer te geven */
weergave()
{
ongetekende int s_sec, s_trk, e_sec, e_trk, i, t1, t2;
char type[20], boot[5];
printf("\n\nDeel. Opstarten Startlocatie Eindlocatie
Relatief aantal");
printf("\nType Zijde Cilinder Sector Zijde Cilinder
Sector Sectoren Sectoren\n");
voor ( i = 0 ; i <= 3 ; i++ )
{
als ( p.pt[i].bootable == 0x80 )
strcpy ( boot, "Ja" );
anders
strcpy ( boot, "Nee" );
schakelaar ( p.pt[i].parttype )
{
geval 0x00 :
strcpy ( type, "Ongebruikt" ) ; break ;
geval 0x1 :
strcpy (type, "FAT12"); breken;
geval 0x2 :
strcpy (type, "Xenix"); breken;
geval 0x3 :
strcpy (type, "Xenix:usr"); breken;
geval 0x4 :
strcpy (type, "FAT16<32M"); breken;
geval 0x5 :
strcpy ( type, "DOS-Ext." ) ; breken ;
geval 0x6 :
strcpy (type, "FAT16>32M"); breken;
geval 0x7 :
strcpy (type, "NTFS"); breken;
geval 0x0b :
strcpy (type, "FAT32"); breken;
geval 0x0c :
strcpy (type, "FAT32-LBA"); breken;
geval 0x0d :
strcpy (type, "VFAT16"); breken;
geval 0x0e :
strcpy (type, "VFAT16-LBA"); breken;
geval 0x0f :
strcpy (type, "FAT EXT"); breken;
geval 0x17 :
strcpy (type, "HPFS"); breken;
geval 0x81 :
strcpy ( type, "Oude LINUX" ) ; break ;
geval 0x82 :
strcpy (type, "LinuxSwap"); breken;
geval 0x83 :
strcpy (type, "LinuxNative"); breken;
geval 0x85 :
strcpy ( type, "Linux Ext." ) ; breken ;
standaard :
strcpy( type, "Onbekend" ) ; break ;
}
s_sec = ( p.pt[i].start_sec_cyl & 0x3f );
t1 = ( p.pt[i].start_sec_cyl & 0xff00 ) >> 8 ;
t2 = ( p.pt[i].start_sec_cyl & 0x00c0 ) << 2 ;
t_trk = t1 | t2 ;
e_sec = ( p.pt[i].end_sec_cyl & 0x3f ) ;
t1 = ( p.pt[i].end_sec_cyl & 0xff00 ) >> 8 ;
t2 = ( p.pt[i].end_sec_cyl & 0x00c0 ) << 2 ;
e_trk = t1 | t2 ;
printf ( "\n%6s %3s", type, boot ) ;
printf ( "%4d %6d %8d", p.pt[i].start_zijde,
(s_trk,s_sec );
printf ( "%7d %6u %8u", p.pt[i].eind_zijde, e_trk,
e_sec ) ;
printf ( " %10lu %10lu", p.pt[i].part_beg,
p.pt[i].plen ) ;
}
retourneer 0;
}
Formatteren van “Track 0 Bad” floppy
Dit programma wordt gebruikt om floppy's te formatteren die slechte sectoren op hun spoor 0 hebben en die, wanneer ze geformatteerd worden met DOS of Windows, foutmeldingen weergeven zoals "Spoor 0 BAD". U kunt het echter ook gebruiken om normale floppy's te formatteren.
De codering van het programma is gegeven op de disk die bij dit boek is bijgevoegd met de naam "TTFORMAT.C". De werkende logica van het programma is hetzelfde als het programma gepubliceerd in PCQUEST computer magazine, in de editie van februari 2003.
In dit programma proberen we dit type floppy's herbruikbaar te maken door ze te formatteren. Het programma klinkt alsof je de floppy disk zelfs met een paar slechte sectoren erop kunt hanteren. Als de eerste sector van de disk echter slecht is, kan de floppy niet worden geformatteerd.
Het programma herschrijft alle DBR-, FAT- en Root Directory-informatie. Als er slechte sectoren op het oppervlak van de schijf staan, worden ze in FAT als slecht gemarkeerd.
In de codering van het programma wordt de structuur BPB gebruikt om het BIOS Parameter Block van de DBR te schrijven. De structuur boot_sector wordt gebruikt om de DBR van de disk te schrijven. De structuur address_field wordt gebruikt voor interactie met het aantal cylinders, heads en sectors per track en met de grootte van de sector.
De verschillende functies die bij het coderen van het programma worden gebruikt, worden in de onderstaande tabel met een beschrijving ervan weergegeven.
Het volumeserienummer van de floppydisk wordt door DOS berekend op basis van de huidige datum en tijd van de systeemklok.
Het eerste deel van het serienummer wordt berekend door de som van de tijd (seconden en honderdsten van een seconde) en de datum (maand en dag). Het tweede deel van het serienummer is gelijk aan de som van de tijd (uren en minuten) en de datum (jaar).
Alle berekeningen worden uitgevoerd in het hexadecimale systeem. Laten we bijvoorbeeld aannemen dat u de floppy in een DOS-omgeving hebt geformatteerd om 11:16:28:65 op 23-10-2003. Laten we nu het serienummer van de disk berekenen.
De tijd in (seconden en honderdsten van seconden) formaat is
= (28 en 65)
= (1CH en 41H)
Schrijf het als 1C41
Op dezelfde manier is de datum in (maand en dag) formaat
= (10 en 23)
= (0AH en 17H)
Schrijf het als 0A17
Op dezelfde manier is de tijd in (uren en minuten) formaat,
= (11 en 16)
= (0BH en 10H)
Schrijf het als 0B10
En het jaar zal zijn
= 2003
= 07D3
Laten we nu het serienummer van de floppy disk berekenen, volgens de eerder gegeven beschrijving. Het eerste deel van het serienummer zal zijn (1C41 + 0A17) = 2658 en het tweede deel van het serienummer zal zijn (0B10 + 07D3) = 12E3.
Het schrijven van de schijfbewerkingstool
De codering van het bewerkingsprogramma op schijf staat op de bij dit boek meegeleverde schijf, met de bestandsnaam "TTEDITOR.C". Met dit programma kunt u het oppervlak van harde schijven of floppydisks analyseren. Zelfs tijdens het schrijven van dit boek heb ik meestal TTEDITOR gebruikt om het schijfoppervlak te analyseren of om schijfmodificaties uit te voeren.
Dit zijn enkele belangrijke taken die dit bewerkingsprogramma kan uitvoeren:
- Sector-voor-sectorinformatie lezen van het oppervlak van harde schijven en floppy disks.
- Schrijf een reservekopie van elke sector naar een bestand.
- Sectorgegevens uit een bestand herstellen.
- Verander één byte.
- Rekenmachine voor het omzetten van hexadecimale getallen naar decimaal en binair.
Het programma gebruikt de functies biosdisk( ) en _bios_disk( ) om toegang te krijgen tot schijven. Als u een schijf groter dan 8,4 GB wilt analyseren, moet u het programma aanpassen zodat de extensie INT 13H wordt gebruikt. De beschrijving van de in het programma gebruikte functies vindt u in de volgende tabel:
| Functie |
Beschrijving |
| achtergrond() |
creëert de achtergrond en het frame van het eerste scherm |
| clslijn( ) |
Wordt gebruikt om een hele regel van het scherm te wissen, zoals aangegeven door het regelnummer. |
| update( ) |
Functie om alle weergavefuncties op het scherm aan te roepen |
| schrijfnaarbestand() |
Functie voor het schrijven van sectorgegevens naar een gebruikersbestand. |
| schrijven naar sector ( ) |
De functie voor het herstellen van een sector uit een opgegeven bestand. |
| msgdisp() |
Functie voor het weergeven van berichten op het scherm. |
| wijziging( ) |
Functie om één byte van een door de gebruiker opgegeven sector te wijzigen. |
| kader( ) |
Sector display frame structuur tekening functie |
| dispmax( ) |
Geeft het maximale CHS-nummer van een schijf weer (geldig voor schijven tot 8,4 GB) |
| weergave( ) |
Sector en informatie op het scherm weergeven. |
| hextodec( ) |
Functie om een hexadecimaal getal om te zetten naar het overeenkomstige decimale en binaire getal. |
