In questo capitolo parleremo di come utilizzare le informazioni MBR, DBR, FAT e della directory root per sviluppare utilità che possono aiutarci a gestire i dati, ottimizzare l'archiviazione o risolvere molti problemi del disco.

Solitamente questi programmi sono una soluzione a un problema specifico. In questo capitolo sono state esaminate alcune utilità e la loro programmazione.

Nascondere le sezioni

In genere, l'utilità per nascondere le partizioni viene utilizzata dagli utenti che lavorano sullo stesso sistema informatico utilizzato dagli altri utenti. Se ci sono molti utenti su un computer, c'è un'alta probabilità che i dati di un altro utente possano essere letti, rubati o eliminati.

In tal caso, se l'utente ha dati importanti o informazioni riservate sullo stesso computer, potrebbe voler nascondere la partizione in cui si trovano i suoi dati, in modo che il sistema operativo non possa accedervi e quindi nessun altro utente possa accedervi.

Quando l'utente desidera lavorare sul sistema, può accedere nuovamente alla sezione semplicemente aprendola. In genere, tali eventi si verificano in istituti professionali in cui i computer sono utilizzati da molti studenti, ma gli studenti più grandi sono sempre preoccupati per i loro dati importanti o per i loro progetti di lavoro. Analogamente a quanto avviene per mancanza di conoscenze, un nuovo studente potrebbe danneggiare o addirittura cancellare i propri dati.

Come si fa a nascondere una sezione?

La tabella seguente mostra il formato della partizione nella tabella delle partizioni MBR:

Compensare	Senso	Misurare	Descrizione
ore 00:00	Byte indicatore tipo di avvio	1 byte	Se il byte è 00H, la partizione è inattiva, mentre se il byte è 80H , la partizione è attiva (o avviabile).
01H	Numero di sezione iniziale	1 byte	Numero di partizione iniziale in esadecimale
ore 02:00	Numero del settore e del cilindro dell'inizio della partizione	2 byte	I 6 bit del primo byte costituiscono il numero del settore iniziale, mentre la combinazione dei restanti 2 bit (i due bit più significativi) e degli 8 bit dell'altro byte (i restanti 8 bit meno significativi del numero a 10 bit) costituisce il numero del cilindro iniziale della partizione.
ore 04:00	Byte indicatore del file system	1 byte	Byte indicatore del file system in esadecimale (per un elenco completo dei byte indicatori di partizione, vedere il capitolo "Approccio logico a dischi e sistemi operativi" discusso in precedenza in questo libro)
ore 05:00	Numero di fine intestazione della sezione	1 byte	Numero di partizione finale in esadecimale
ore 06:00	Numero di settore e cilindro alla fine della sezione	2 byte	I 6 bit del primo byte costituiscono il numero del settore finale, mentre la combinazione dei restanti 2 bit (i due bit più significativi) e degli 8 bit dell'altro byte (i restanti 8 bit meno significativi del numero a 10 bit) costituisce il numero del cilindro finale della partizione.
ore 08:00	Numero assoluto del settore dell'inizio della partizione	4 byte	Numero di settori tra MBR e il primo settore nella partizione
ore 0	Numero assoluto del settore della fine della partizione	4 byte	Numero di settori nella sezione
		Totale = 16 byte

All'offset 04H, in ogni voce di partizione, è presente un byte indicatore del file system. Questo byte indicatore rappresenta il tipo di file system di questa partizione. Se il valore di questo byte cambia, cambia l'identificazione della sezione.

Ad esempio, il valore del byte indicatore di partizione per "DOS 12-Bit FAT" è 0x01. Se questo valore viene modificato in 0x11, l'identificativo del file system nella voce della tabella delle partizioni cambia in "Hidden DOS 12-Bit FAT" (per un elenco completo dei byte indicatori di partizione, vedere il capitolo "Approccio logico a dischi e sistemi operativi" discusso in precedenza in questo libro).

La tabella seguente mostra altri esempi di byte indicatori del file system per alcuni tipi di partizione:

Byte indicatore tipo partizione	Descrizione del file system della partizione
0x01	DOS a 12 bit FAT
0x11	FAT DOS a 12 bit nascosto
0x04	DOS 16 bit FAT (<=32 MB)
0x14	DOS nascosto 16-bit FAT (<=32 MB)
0x05	DOS esteso
0x15	DOS esteso nascosto
0x06	DOS 16 bit di grandi dimensioni (>32 MB)
0x16	DOS nascosto a 16 bit di grandi dimensioni (>32 MB)
0x07	File NTFS
0x17	NTFS nascosto
0x0B	Finestre FAT32
0x1B	Finestre nascoste FAT32
0x0C	Windows FAT32 (LBA)
0x1C	Windows nascosto FAT32 (LBA)
0x0E	Windows FAT16 (LBA)
0x1E	Windows nascosto FAT16 (LBA)
0x0F	Finestre espanse
0x1F	Finestre nascoste espanse

Qui vediamo che la partizione nascosta corrispondente per qualsiasi file system viene trovata aggiungendo il valore 0x10 al suo byte indicatore di sistema.

Sebbene non sia la regola ferrea per nascondere la partizione, funziona anche per la maggior parte dei file system. Il motivo è che quando cambiamo il valore del byte indicatore di partizione, l'identità del file system nella voce della tabella delle partizioni viene modificata. Ed è molto raro che il nuovo file system sia supportato anche dallo stesso sistema operativo.

Scrittura di un programma per nascondere la partizione

Il programma fornito di seguito è utilizzato per nascondere la partizione utilizzando la voce di partizione di quella partizione dalla tabella delle partizioni di MBR. Se si desidera nascondere altre partizioni logiche nel volume esteso, è necessario accedere agli MBR estesi.

Di seguito è riportata la codifica del programma:

/* Programma per nascondere la partizione utilizzando la voce della tabella delle partizioni di quella partizione da MBR */

    #include <bios.h>
  #include <stdio.h>
  int principale(vuoto)
  {
  struct diskinfo_t dinfo;
  int risultato, da nascondere;
  int io;
  static char dbuf[512];/* Buffer dati per la lettura e la scrittura del
  Informazioni sul settore */
  clrscr();
  dinfo.drive = 0x80; /* numero di unità per First
  Disco rigido */
  dinfo.head = 0; /* numero della testina del disco */
  dinfo.track = 0; /* numero traccia */
  dinfo.sector = 1; /* numero settore */
  dinfo.nsectors = 1; /* conteggio settori */
  dinfo.buffer = dbuf; /* buffer dati */

/* Leggi il primo settore del disco */

    risultato = _bios_disk(_DISK_READ, &dinfo);
  se ((risultato & 0xff00) == 0)
  {
  printf("I codici di partizione di quattro voci di partizione sono,
  0x%02x, 0x%02x, 0x%02x e 0x%02x.\n",
  dbuf[450] e 0xff, dbuf[466] e 0xff,
  (il valore predefinito è 0xff, il valore predefinito è 0xff);
  colore del testo(15);
  gotoxy(5,5);cprintf("La voce di partizione in MBR è come
  segue:");
  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);

/* Ottieni l'input dell'utente per nascondere la partizione */

    gotossi(1,15);
  printf("Inserisci il numero della partizione che vuoi nascondere,
  Oppure premi un altro tasto per uscire... ");
  nascondere=getche();
  cambia(per nascondere)
  {
  caso '1': /* Nascondi la prima partizione nella tabella delle partizioni */
  dbuf[450] = dbuf[450] +16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  caso '2': /* Nascondi la seconda partizione nella tabella delle partizioni */
  dbuf[466] = dbuf[466]+16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  caso '3': /* Nascondi la terza partizione nella tabella delle partizioni */
  dbuf[482] = dbuf[482] +16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  case '4': /* Nascondi la quarta partizione nella tabella delle partizioni */
  dbuf[498] = dbuf[498]+16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  predefinito:
  uscita(0);
  }
  se ((risultato & 0xff00) == 0)
  {
  printf("\n\nI nuovi codici di partizione di Four Partition
  Le voci sono 0x%02x, 0x%02x, 0x%02x e 0x%02x.\n",
  dbuf[450] e 0xff, dbuf[466] e 0xff,
  (il valore predefinito è 0xff, il valore predefinito è 0xff);
  ottenere();
  }
  altro
  {
  printf("Impossibile modificare il byte, stato = 0x%02x\n",
  risultato);
  ottenere();
  }
  }
  restituisci 0;
  }

Commenti sulla codifica:

Il programma legge i byte indicatori del file system di tutte e quattro le voci di partizione nella tabella delle partizioni di MBR. La funzione showtype( ) viene utilizzata per mostrare il nome del file system per il valore corrispondente del byte indicatore del file system.

L'utente seleziona la partizione da nascondere dal menu visualizzato sullo schermo, quindi aggiunge 16 (0x10) al valore del byte indicatore del file system di quella partizione per nasconderla.

La codifica della funzione showtype( ) è la seguente:

/* Funzione per mostrare il nome del file system corrispondente al valore del byte indicatore del file system */

    tipo di spettacolo(i)
  {
  interruttore (io)
  {
  caso 0x00 :cprintf("Vuoto"); interruzione;
  caso 0x01 :cprintf("DOS FAT a 12 bit"); interruzione;
  caso 0x02 :cprintf("Radice XENIX"); interruzione;
  caso 0x03 :cprintf("Utente XENIX"); interruzione;
  caso 0x04 :cprintf("DOS 16 bit <32M"); interruzione;
  caso 0x05 :cprintf("Esteso"); interruzione;
  caso 0x06 :cprintf("DOS 16-bit >=32M"); interruzione;
  caso 0x07 :cprintf("OS/2 HPFS"); interruzione;
  caso 0x08 :cprintf("AIX"); interruzione;
  caso 0x09 :cprintf("AIX avviabile"); break;
  caso 0xa :cprintf("Gestione avvio OS/2"); interruzione;
  caso 0xb :cprintf("Win95/98/ME FAT32"); interruzione;
  caso 0xc :cprintf("Win95/98/ME FAT32 (LBA)"); interruzione;
  caso 0xd :cprintf("Win95 FAT16"); interruzione;
  caso 0xe :cprintf("Win95 FAT16 (LBA)"); interruzione;
  caso 0xf :cprintf("Win95 esteso"); interruzione;
  caso 0x11 :cprintf("FAT-12 nascosto");break;
  caso 0x12 :cprintf("Diagnostica Compaq");break;
  caso 0x14 :cprintf("FAT-16 nascosto (<32)");break;
  caso 0x15 :cprintf("Nascosto esteso");break;
  caso 0x16 :cprintf("FAT-16 nascosto");break;
  caso 0x17 :cprintf("NTFS"); interruzione;
  caso 0x40 :cprintf("Venix 80286"); interruzione;
  caso 0x51 :cprintf("Novell?"); interruzione;
  caso 0x52 :cprintf("Microporta"); interruzione;
  caso 0x63 :cprintf("GNU HURD"); interruzione;
  caso 0x64 :
  caso 0x65 :cprintf("Novell Netware"); interruzione;
  caso 0x75 :cprintf("PC/IX"); interruzione;
  caso 0x80 :cprintf("Vecchio MINIX"); break;
  caso 0x81 :cprintf("Linux/MINIX"); interruzione;
  caso 0x82 :cprintf("Scambio Linux"); interruzione;
  caso 0x83 :cprintf("Linux nativo"); interruzione;
  caso 0x85 :cprintf("Linux esteso"); interruzione;
  caso 0x93 :cprintf("Ameba"); interruzione;
  caso 0x94 :cprintf("Ameba BBT"); interruzione;
  caso 0xa5 :cprintf("BSD/386"); interruzione;
  caso 0xa6 :cprintf("OpenBSD"); interruzione;
  caso 0xa7 :cprintf("PASSO SUCCESSIVO"); interruzione;
  caso 0xb7 :cprintf("FS BSDI"); interruzione;
  caso 0xb8 :cprintf("Scambio BSDI"); interruzione;
  caso 0xc7 :cprintf("Siringa"); interruzione;
  caso 0xdb :cprintf("CP/M"); interruzione;
  caso 0xe1 :cprintf("Accesso DOS"); break;
  caso 0xe3 :cprintf("DOS R/O"); interruzione;
  caso 0xf2 :cprintf("DOS secondario"); interruzione;
  caso 0xff :cprintf("BBT"); interruzione;
  predefinito :cprintf("SCONOSCIUTO");
  }
  restituisci 0;
  }

Scrittura di un programma per scoprire la partizione

Il programma per mostrare la partizione nascosta funziona esattamente in modo opposto al programma che nasconde il programma. In questo programma sottraiamo 16 (0x10) dal valore del byte indicatore del file system della partizione nascosta.

La codifica del programma è la seguente:

/* Programma per visualizzare la partizione nascosta dal programma precedente */

    #include <bios.h>
  #include <stdio.h>
  int principale(vuoto)
  {
  struct diskinfo_t dinfo;
  int risultato, da nascondere;
  int io;
  static char dbuf[512];/* Buffer dati */
  clrscr();
  dinfo.drive = 0x80; /* numero di unità per
  Primo disco rigido */
  dinfo.head = 0; /* numero della testina del disco */
  dinfo.track = 0; /* numero traccia */
  dinfo.sector = 1; /* numero settore */
  dinfo.nsectors = 1; /* conteggio settori */
  dinfo.buffer = dbuf; /* buffer dati */
  risultato = _bios_disk(_DISK_READ, &dinfo);
  se ((risultato & 0xff00) == 0)
  {
  printf("I codici di partizione di quattro partizioni
  Le voci sono 0x%02x, 0x%02x, 0x%02x e 0x%02x.\n",
  dbuf[450] e 0xff, dbuf[466] e 0xff,
  (il valore predefinito è 0xff, il valore predefinito è 0xff);
  colore del testo(15);
  gotossi(5,5);
  cprintf("La voce della partizione in MBR è la seguente:");
  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);

/* Ottieni l'input Usa per visualizzare la partizione */

    gotoxy(1,15);printf("Inserisci il numero di partizione, che
  scopri, oppure premi qualsiasi altro tasto per
  Uscita... ");
  nascondere=getche();
  cambia(per nascondere)
  {

/* Mostra la prima partizione della tabella delle partizioni */

    caso '1':
  dbuf[450] = dbuf[450] -16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  /* Mostra la seconda partizione della tabella delle partizioni */
  caso '2':
  dbuf[466] = dbuf[466]-16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  /* Mostra la terza partizione della tabella delle partizioni */
  caso '3':
  dbuf[482] = dbuf[482] -16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  /* Mostra la quarta partizione della tabella delle partizioni */
  caso '4':
  dbuf[498] = dbuf[498]-16;
  risultato = _bios_disk(_DISK_WRITE, &dinfo);
  rottura;
  predefinito:
  uscita(0);
  }
  se ((risultato & 0xff00) == 0)
  {
  printf("\n\nI nuovi codici di partizione di Four Partition
  Le voci sono 0x%02x, 0x%02x, 0x%02x e 0x%02x.\n",
  dbuf[450] e 0xff, dbuf[466] e 0xff,
  (il valore predefinito è 0xff, il valore predefinito è 0xff);
  ottenere();
  }
  altro
  {
  printf("Impossibile modificare il byte, stato = 0x%02x\n",
  risultato);
  ottenere();
  }
  }
  restituisci 0;
  }

Commenti sul programma

Fai attenzione quando inserisci il numero di partizione da mostrare. Se il numero di partizione viene inserito in modo errato per errore, le informazioni del file system di quella partizione verranno modificate e la partizione potrebbe diventare inaccessibile. Tuttavia, il programma discusso in precedenza per nascondere le partizioni, potrebbe aiutarti a correggere il byte indicatore del file system di quella partizione.

Scrittura di un programma per eliminare la partizione

Il programma per eliminare la partizione è utilizzato per scopi di risoluzione dei problemi. Ad esempio, supponiamo che tu abbia le partizioni del file system FAT32 sul tuo disco. Ora hai deciso di installare contemporaneamente il sistema operativo LINUX sul tuo disco.

Se in qualche modo, l'installazione del sistema operativo viene interrotta nel frattempo, nella fase in cui venivano apportate modifiche alla tabella delle partizioni dell'MBR. In tali casi, ci sono molte possibilità che la partizione in cui si stava per installare l'altro sistema operativo diventi inaccessibile.

In questo caso lo spazio su disco della partizione persa diventa inutile perché inaccessibile. Tuttavia, se eliminiamo in ogni caso le informazioni sulla partizione di quella partizione dalla tabella delle partizioni, possiamo di nuovo rendere utilizzabile questo spazio usando il comando FDISK del DOS.

Di seguito è riportato il programma per eliminare la voce di partizione dalla tabella delle partizioni di MBR:

/* Programma per eliminare la seconda voce di partizione dalla tabella delle partizioni di MBR */

    # includere <bios.h>
  /* struttura per leggere la voce della partizione dalla tabella delle partizioni */
  partizione struttura
  {
  /* Byte di partizione attiva */
  unsigned char avviabile;
  /* Testa iniziale */
  carattere senza segno start_side ;
  /* combinazione di settore di partenza e numero di cilindro */
  intero senza segno start_sec_cyl ;
  /* Byte indicatore del file system */
  tipo di parte di un char senza segno;
  /* Titolo finale */
  carattere senza segno end_side ;
  /* combinazione di settore di partenza e numero di cilindro */
  intero senza segno end_sec_cyl ;
  /* Numero di settore relativo */
  parte lunga non firmata_inizio ;
  /* Lunghezza della partizione in settori */
  senza segno lungo plen ;
  } ;
  /* Struttura per leggere-scrivere MBR */
  parte struttura
  {
  /* IPL (caricatore di programma iniziale) */
  carattere senza segno master_boot[446] ;
  /* Tabella delle partizioni */
  struct partizione pt[4] ;
  /* Numero magico */
  int ultimidue ;
  } ;
  parte della struttura p ;
  vuoto principale()
  {
  intero senza segno t1,t2;
  clrscr();
  biosdisk ( 2, 0x80, 0, 0, 1, 1, &p ) ;
  display(); /* visualizza le informazioni di
  Tabella delle partizioni */
  ottenere();
  p.pt[1].avviabile = 0;
  p.pt[1].start_side = 0 ;
  p.pt[1].start_sec_cyl = 0 ;
  p.pt[1].tipoparte = 0;
  p.pt[1].end_side = 0;
  p.pt[1].end_sec_cyl = 0;
  p.pt[1].part_beg = 0;
  p.pt[1].plen = 0;
  printf("\n\n\n Dopo aver eliminato la seconda partizione
  Voce dalla tabella delle partizioni MBR,");
  printf("\n La tabella delle partizioni verrà modificata come
  Segue: ");
  /* Per eliminare le informazioni sulla seconda partizione dalla partizione
  tabella di MBR Rimuovi le barre in avanti dalla
  Funzione biosdisk( ). Non usare con noncuranza, partizione
  informazioni sulla seconda partizione della tabella delle partizioni
  essere cancellato completamente. */
  ////// biosdisk ( 3, 0x80, 0, 0, 1, 1, &p ) ;
  display(); /* Visualizza le informazioni della partizione
  tabella dopo la modifica */
  ottenere();
  }

Commenti sul programma:

Rimuovere il commento dalla funzione biosdisk (3, 0x80, 0, 0, 1, 1, &p) per eliminare la seconda partizione dalla tabella delle partizioni di MBR.

Per eliminare la partizione, tutti i suoi parametri vengono impostati su 0 nella voce della tabella delle partizioni in MBR. Ricorda sempre che se elimini la partizione estesa, anche tutte le partizioni logiche di quella partizione estesa diventeranno inaccessibili.

La funzione display( ) viene utilizzata per visualizzare la tabella delle partizioni di MBR. La codifica della funzione è la seguente:

/* Funzione per visualizzare la tabella delle partizioni di MBR */

    display()
  {
  intero senza segno s_sec, s_trk, e_sec, e_trk, i, t1, t2 ;
  tipo di carattere[20], avvio[5] ;
  printf("\n\nPart. Boot Posizione di partenza Posizione di arrivo
  Numero relativo di");
  printf("\nTipo Lato Cilindro Settore Lato Cilindro
  Settore Settori Settori\n");
  per ( i = 0 ; i <= 3 ; i++ )
  {
  se ( p.pt[i].bootable == 0x80 )
  strcpy( avvio, "Sì" ) ;
  altro
  strcpy(avvio, "No" ) ;
  interruttore ( p.pt[i].parttype )
  {
  caso 0x00 :
  strcpy(tipo, "Non utilizzato"); break;
  caso 0x1 :
  strcpy (tipo, "FAT12" ) ; interruzione ;
  caso 0x2 :
  strcpy (tipo, "Xenix" ) ; interruzione ;
  caso 0x3 :
  strcpy (tipo, "Xenix:usr" ) ; interruzione ;
  caso 0x4 :
  strcpy (tipo, "FAT16<32M" ) ; interruzione ;
  caso 0x5 :
  strcpy ( tipo, "DOS-Ext." ) ; break ;
  caso 0x6 :
  strcpy (tipo, "FAT16>32M" ) ; interruzione ;
  caso 0x7 :
  strcpy (tipo, "NTFS" ) ; interruzione ;
  caso 0x0b :
  strcpy (tipo, "FAT32" ) ; interruzione ;
  caso 0x0c :
  strcpy (tipo, "FAT32-LBA" ) ; interruzione ;
  caso 0x0d :
  strcpy (tipo, "VFAT16" ) ; interruzione ;
  caso 0x0e :
  strcpy (tipo, "VFAT16-LBA" ) ; interruzione ;
  caso 0x0f :
  strcpy (tipo, "FAT EXT" ) ; interruzione ;
  caso 0x17 :
  strcpy (tipo, "HPFS" ) ; interruzione ;
  caso 0x81 :
  strcpy (tipo, "Vecchio LINUX" ) ; break ;
  caso 0x82 :
  strcpy (tipo, "LinuxSwap" ) ; interruzione ;
  caso 0x83 :
  strcpy (tipo, "LinuxNative" ) ; interruzione ;
  caso 0x85 :
  strcpy (tipo, "Linux Ext." ) ; break ;
  predefinito :
  strcpy(tipo, "Sconosciuto"); 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 ;
  traccia = 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", tipo, avvio ) ;
  printf( "%4d %6d %8d", p.pt[i].start_side,
  (s_traccia,s_sec ) ;
  printf( "%7d %6u %8u", p.pt[i].end_side, e_trk,
  (e_sec );
  printf( " %10lu %10lu", p.pt[i].part_beg,
  p.pt[i].plen ) ;
  }
  restituisci 0;
  }

Formattazione floppy "Traccia 0 non valida"

Questo programma viene utilizzato per formattare quei floppy che hanno settori danneggiati sulla traccia 0 e quando vengono formattati con DOS o Windows, visualizzano messaggi di errore come "Traccia 0 BAD". Tuttavia puoi anche utilizzarlo per formattare floppy normali.

La codifica del programma è stata fornita nel disco allegato a questo libro con il nome "TTFORMAT.C". La logica di funzionamento del programma è la stessa del programma pubblicato sulla rivista di computer PCQUEST, nell'edizione di febbraio 2003.

In questo programma, cerchiamo di rendere questo tipo di floppy riutilizzabili formattandoli. Il programma sembra che sia possibile gestire il floppy disk anche con alcuni settori danneggiati. Tuttavia, se il primo settore del disco è danneggiato, il floppy non può essere formattato.

Il programma riscrive tutte le informazioni DBR, FAT e Root Directory. Se ci sono settori danneggiati sulla superficie del disco, vengono contrassegnati come danneggiati in FAT.

Nella codifica del programma, la struttura BPB è utilizzata per scrivere il BIOS Parameter Block del DBR. La struttura boot_sector è utilizzata per scrivere il DBR del disco. La struttura address_field è utilizzata per interagire con il numero di cilindri, testine e settori per traccia e con la dimensione del settore.

Nella tabella seguente sono riportate le diverse funzioni utilizzate nella codifica del programma e la loro descrizione.

strumento di modifica del disco

Il numero di serie del volume del floppy disk viene calcolato dal DOS in base alla data e all'ora correnti dell'orologio di sistema.

La prima parte del numero seriale è calcolata dalla somma del tempo (secondi e centesimi di secondo) e della data (mese e giorno). La seconda parte del numero seriale è uguale alla somma del tempo (ore e minuti) e della data (anno).

Tutti i calcoli vengono eseguiti in sistema esadecimale. Ad esempio, supponiamo che tu abbia formattato il floppy in ambiente DOS alle 11:16:28:65 del 23/10/2003. Ora calcoliamo il numero di serie del disco.

    Il tempo nel formato (secondi e centesimi di secondo) è
  = (28 e 65)
  = (1CH e 41H)
  Scrivilo come 1C41
  Allo stesso modo, la data nel formato (mese e giorno) è
  = (10 e 23)
  = (0AH e 17H)
  Scrivilo come 0A17
  Allo stesso modo, il tempo nel formato (ore e minuti) è,
  = (11 e 16)
  = (0BH e 10H)
  Scrivilo come 0B10
  E l'anno sarà
  = 2003
  = 07D3

Ora, calcoliamo il numero di serie del floppy disk, secondo la descrizione data in precedenza. La prima parte del numero di serie sarà (1C41 + 0A17) = 2658 e la seconda parte del numero di serie sarà (0B10 + 07D3) = 12E3.

Scrittura dello strumento di modifica del disco

La codifica del programma di modifica del disco è stata fornita sul disco allegato a questo libro, con il nome file "TTEDITOR.C". È possibile utilizzare questo programma per analizzare la superficie dei dischi rigidi o dei floppy disk. Anche durante la scrittura di questo libro ho utilizzato per la maggior parte del tempo TTEDITOR per analizzare la superficie del disco o per apportare modifiche al disco.

Ecco alcune delle attività importanti che questo programma di editing può svolgere:

Lettura di informazioni settore per settore dalla superficie di dischi rigidi e floppy disk.
Scrivere una copia di backup di qualsiasi settore in un file.
Recupera i dati del settore dal file.
Cambia un byte.
Calcolatrice per convertire i numeri esadecimali in decimali e binari.

Il programma utilizza le funzioni biosdisk() e _bios_disk() per accedere ai dischi. Se si desidera analizzare un disco di dimensioni superiori a 8,4 GB, modificare il programma in modo che utilizzi le estensioni INT 13H. La descrizione delle funzioni utilizzate nel programma è riportata nella tabella seguente:

Funzione	Descrizione
sfondo()	crea lo sfondo e la cornice della prima schermata
linea di classificazione( )	Utilizzato per cancellare un'intera riga dallo schermo specificata dal numero di riga.
aggiornamento( )	Funzione per richiamare tutte le funzioni di visualizzazione sullo schermo
scrivisufile()	Funzione per scrivere i dati del settore in un file utente.
scrivi al settore ( )	La funzione di ripristino di un settore da un file specificato.
messaggiodisp()	Funzione di visualizzazione dei messaggi sullo schermo.
modifica( )	Funzione per modificare un byte di qualsiasi settore specificato dall'utente.
telaio( )	Funzione di disegno della struttura del telaio di visualizzazione del settore
dispmax( )	Visualizza il numero massimo di CHS di un disco (valido per dischi fino a 8,4 GB)
visualizzare( )	Visualizza il settore e le informazioni sullo schermo.
esatodec( )	Funzione per convertire un numero esadecimale nel corrispondente numero decimale e binario.

Recupero dati con e senza programmazione

Autore: Tarun Tyagi

← Capitolo precedente

Capitolo successivo →