Шустрый
Профиль
Группа: Участник
Сообщений: 56
Регистрация: 22.3.2009
Где: Украна, Донецк
Репутация: нет
Всего: нет
|
Есть задача найти последовательность F8FF (т.е.) начало копии FAT. Немного не разберусь с кодом, где можно вытащить эту последовательность. | Код |
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <bios.h>
#include <stdlib.h>
#include <string.h>
#include <dir.h>
#define CMD_READ 2
#define CMD_RESET 0
#define HEAD 0
#define TRACK 0
#define SECT 1
void wait();
long FATclst(long Nclust);
int FATtype; // текущий тип FAT
long oldsec; // последний считанный сектор
int BaseHead; //
int BaseSect; //
int BaseTrack; // boot CHS
unsigned int RootHead; //
unsigned int RootSect; //
unsigned int RootTrack; // root CHS
int drive = 0x80;
int active = 0;
long delay_; // delay boot/root
char sect_buf[1024]; // buffer for root elements
unsigned short Root1216_Nsectors; // number of sectors in root (fat12/16)
char chain_choice;
union BOOTstruct
{
struct
{
char res1[11];
unsigned short SectSize; // 11
char CS; // 13
unsigned short ResSecs; // 14
char Fat; // 16
unsigned short RootSize; // 17
unsigned short TotSecs; // 19
char Med; // 20
unsigned short FatSize; // 22
unsigned short TrkSecs; // 24
unsigned short HeadCnt; // 26
unsigned long HindSec; // 28
unsigned long TotSize32; // 32
union
{
struct
{
char izv_num; // 36
char reserv; // 37
char boot_sig; // 38
long vol_id; // 39
char vol_name[11]; // 43
char file_sys_type[8];//54
}f1216;
struct
{
unsigned long FatSize32; // 36
unsigned short Ext_fl; // 40
unsigned short Fs_ver; // 42
unsigned long Root_clus; // 44
unsigned short Fs_info; // 48
unsigned short BKBootSec;// 50
char reserv[12]; // 52
}f32;
}fat;
char BS_izv_num; // 64
char BS_reserv; // 65
char Boot_sig; // 66
long vol_id; // 67
char vol_lab[11];// 71
char file_sys_type[8];//82
}bs;
char buffer[1024];
} BOOT;
typedef struct
{
unsigned char Bot;
unsigned char Hds;
unsigned char Sec_s;
unsigned char Cyl_s;
unsigned char Sys;
unsigned char Hde;
unsigned char Sec_e;
unsigned char Cyl_e;
unsigned long No;
unsigned long Size;
} elem; // MBR component
typedef struct
{
unsigned char name[8];
char ext[3];
char attr;
char reserv[8];
unsigned int extclust; // fat32
int time;
int date;
unsigned int begclust;
long size;
} RootStruct;
union
{ //буфер под максимальный сектор 1024б
unsigned int buffer1[512]; //для FAT16
unsigned long buffer2[256]; //для FAT32
unsigned char buffer3[1024];//для FAT12
} buf;
void logtophys(long logsect,unsigned int *Cyl,unsigned int *Head,unsigned int *Sect);
void readsector(int drive,int head,int track,int sect,void *buf);
void read_mbr(unsigned,unsigned,unsigned,unsigned);
void ReadBOOT(unsigned drive,elem far *ptr);
void ReadInBOOT(int drive,int head,int track,int sect);
void printfile(RootStruct *rptr);
void FATFOLDER(unsigned int ActHead,unsigned int ActSect,unsigned int ActTrack,long num_in_fat,char level);
void print_chain(RootStruct *x);
int main()
{
char key;
clrscr();
oldsec = 0;
read_mbr(drive,HEAD,TRACK,SECT);
if(!active) { printf("active disc not found....\n"); getch(); return 1; };
FATFOLDER(RootHead,RootSect,RootTrack,2,0); // calling for FAT32
printf("press any key.\n");
getch();
return 0;
};
void wait()
{
if(wherey() > 23)
{
getch();
clrscr();
}
}; // end wait
long FATclst(long Nclust)
{
long nsect, //номер сектора от начала FAT
logsect, //лог. номер сектора
offs; //смещение от начала сектора
unsigned long clst; //номер кластера
unsigned int ntr, //номер дорожки
nsc,
nhd;
unsigned char b1,b2; //промеж.перем. для случая перехода через границу сектора
clst=Nclust; //clst-номер текущего кластера
if(FATtype==32)
{
nsect=(long)((clst<<2)/BOOT.bs.SectSize); //определение номера сектора
offs=((clst<<2) % BOOT.bs.SectSize)>>2; //и смещения от начала сектора
}
else
if(FATtype==16)
{
nsect=(long)((clst<<1)/BOOT.bs.SectSize);
offs=((clst<<1) % BOOT.bs.SectSize)>>1;
}
else
if(FATtype==12)
{
nsect=(long)(((clst*3)>>1)/BOOT.bs.SectSize);
offs=(((clst*3)>>1) % BOOT.bs.SectSize);
}
else
return(-1);
logsect=BOOT.bs.ResSecs+nsect; //определение лог.номера сектора
logtophys(logsect,&ntr,&nhd,&nsc); //перевод в физические координаты
if(logsect!=oldsec)
{
readsector(drive,nhd,ntr,nsc,buf.buffer2);
oldsec=logsect;
}
if(FATtype==16)
{
clst=buf.buffer1[offs];
if((clst>=0xFFF8)&&(clst<=0xFFFF)) // конец цепочки
return(0);
else
if((clst==0xFFF7)||(clst==0)) // пустой или BAD кластер
return(-1);
}
else
if(FATtype==32)
{
clst=buf.buffer2[offs];
if((clst>=0x0FFFFFF8)&&(clst<=0x0FFFFFFF)) // конец цепочки
return(0);
else
if((clst==0x0FFFFFF7)||(clst==0)) // пустой или BAD кластер
return(-1);
}
else
{ // FAT12
if(offs!=BOOT.bs.SectSize-1) // если элемент не переходит границу сектора
{
if(!(clst%2)) // кластер четный
clst=buf.buffer3[offs]+((buf.buffer3[offs+1]&0x0F)<<8);
else
clst=(buf.buffer3[offs+1]<<4)+((buf.buffer3[offs]&0xF0)>>4);
}
else // если элемент переходит границу сектора
{
b1=buf.buffer3[BOOT.bs.SectSize-1]; //запоминаем последний байт сектора
logsect++;
oldsec=logsect;
logtophys(logsect,&ntr,&nhd,&nsc);
readsector(drive,nhd,ntr,nsc,buf.buffer3);
b2=buf.buffer3[0]; // запоминаем первый байт сектора
if(!(clst%2))
clst=b1+((b2&0x0F)<<8);
else
clst=(b2<<4)+((b1&0xF0)>>4);
}
if((clst>=0xFF8)&&(clst<=0xFFF))
return(0);
else
if((clst==0xFF7)||(clst==0))
return(-1);
}
return(clst); //возвращаем номер кластера
};//--------------------------------------------------------// end FAT clst
void logtophys(long logsect,unsigned int *Cyl,unsigned int *Head,unsigned int *Sect)
{
long int i;
(*Head)=BaseHead;
(*Cyl)=BaseTrack;
(*Sect)=BaseSect; // boot CHS
*Sect += (logsect%(BOOT.bs.TrkSecs));
logsect = logsect / (BOOT.bs.TrkSecs);
*Head += (logsect%(BOOT.bs.HeadCnt));
logsect = logsect / (BOOT.bs.HeadCnt);
*Cyl += logsect;
if(*Sect > BOOT.bs.TrkSecs)
{ *Sect -= BOOT.bs.TrkSecs; (*Head)++; }
if(*Head >= BOOT.bs.HeadCnt)
{ *Head -= BOOT.bs.HeadCnt; (*Cyl)++; }
};//--------------------------------------------------------// end log to phys
void readsector(int drive,int head,int track,int sect,void *buf)
{
int error_count = 0, //счетчик ошибок
res; // код ошибок
while(error_count < 3)
{
res = biosdisk(2,drive,head,track,sect,1,buf);
if(!res)
return;
error_count++;
biosdisk(0,drive,head,track,sect,1,buf);
}
printf("Error reading disc.\n");
getch();
exit(1);
};//--------------------------------------------------------// end read sector
void read_mbr(unsigned drive,unsigned head,unsigned track,unsigned sect)
{
char buffer[1024];
int i;
elem far *ptr;
unsigned segm, offset, Head, Track, Sect;
readsector(drive,head,track,sect,buffer);
segm = FP_SEG(buffer) + 0x1B;
offset = FP_OFF(buffer) + 0xE;
ptr = (elem far*)MK_FP(segm, offset);
for(i=1;(i<=4)&&(!active);i++)
{
if(!ptr->Sys) break;
if((ptr->Bot == 0x80)||(ptr->Sys == 5))
{
switch(ptr->Sys)
{
case 1: FATtype=12;
ReadBOOT(drive,ptr);
break;
case 11:FATtype=32;
ReadBOOT(drive,ptr);
break;
case 6: FATtype=16;
ReadBOOT(drive,ptr);
break;
case 5: Head = (unsigned)ptr->Hds;
Track = (unsigned)ptr->Cyl_s + 256*(((unsigned) ptr->Sec_s)>>6);
Sect = 0x3F&(unsigned)ptr->Sec_s;
read_mbr(drive,Head,Track,Sect);
break;
default: ;
};
}
segm++;
ptr = (elem far*)MK_FP(segm, offset);
}
};//--------------------------------------------------------// end read mbr
void ReadBOOT(unsigned drive,elem far *ptr)
{
active = 1;
BaseHead = (unsigned)ptr->Hds;
BaseTrack = ((unsigned)ptr->Cyl_s + 256 * (((unsigned)ptr->Sec_s) >>6 ));
BaseSect = (0x3F & ptr->Sec_s);
ReadInBOOT(drive,BaseHead,BaseTrack,BaseSect);
};//--------------------------------------------------------// end ReadBOOT
void ReadInBOOT(int drive,int head,int track,int sect)
{
readsector(drive,head,track,sect,BOOT.buffer);
delay_ = BOOT.bs.ResSecs;
if(BOOT.bs.FatSize)
delay_ += (BOOT.bs.Fat)*(BOOT.bs.FatSize);
else
delay_ += (BOOT.bs.Fat)*(BOOT.bs.fat.f32.FatSize32);
logtophys(delay_,&RootTrack,&RootHead,&RootSect);
};//--------------------------------------------------------// end ReadInBOOT
void printfile(RootStruct *rptr)
{
int i;
for(i=0;i<8;i++)
if(rptr->name[i] == ' ') i=8;
else
putch(rptr->name[i]);
if(rptr->ext[0] != ' ')
{
putch('.');
for(i=0;i<3;i++)
putch(rptr->ext[i]);
}
printf("\n");
wait();
};//--------------------------------------------------------// end printfile
void FATFOLDER(unsigned int ActHead,unsigned int ActSect,unsigned int ActTrack,long num_in_fat,char level)
{
if((FATtype!=12) && (FATtype!=16) && (FATtype!=32)) return;
if(level > 40) return;
char line[] = "----------------------------------------";
int Ofs;
int sector_in_cluster;
unsigned short max_sector_in_this_cluster;
unsigned short ext_ofs=0; // extended offset
unsigned long LOGADR;
int cond,cond2;
long next_clust;
RootStruct *rptr;
RootStruct thisfolder;
RootStruct thisfile;
unsigned int bufHead,bufSect,bufTrack;
unsigned long newclust;
if(FATtype!=32)
{
if(num_in_fat==0) // ROOT
max_sector_in_this_cluster = Root1216_Nsectors;
else
{
max_sector_in_this_cluster=BOOT.bs.CS;
ext_ofs = Root1216_Nsectors;
}
}
else
max_sector_in_this_cluster=BOOT.bs.CS; // FAT32
line[level]=0;
readsector(drive,ActHead,ActTrack,ActSect,sect_buf);
cond2=0;
while(!cond2) //------------------------// cluster'S
{
cond=0;
sector_in_cluster=0;
Ofs=0;
while(!cond) //----------// 1 cluster
{
rptr = (RootStruct *)(sect_buf + Ofs);
if(rptr->name[0]==0)
cond=2; // last file found
else
{
if(rptr->attr & FA_RDONLY)
{
printf("%s[FILE]: ",line);
printfile(rptr);
thisfile=*rptr;
print_chain(&thisfile);
}
if(rptr->attr & FA_DIREC)
if(rptr->name[0] != '.')
if(rptr->name[0] != 0xE5)
{
printf("%s[FOLDER]: ",line);
printfile(rptr);
if(FATtype!=32)
{
newclust = rptr->begclust;
LOGADR = delay_ +((newclust-2)*BOOT.bs.CS)+Root1216_Nsectors;
}
else
{
newclust = ((long)(rptr->begclust)&0x0000ffff) + ((long)(rptr->extclust)<<16);
LOGADR = delay_ +((newclust-2)*BOOT.bs.CS);
}
logtophys(LOGADR,&bufTrack,&bufHead,&bufSect);
FATFOLDER(bufHead,bufSect,bufTrack,newclust,level+1);
readsector(drive,ActHead,ActTrack,ActSect,sect_buf); // recovery
}
}
Ofs += 32;
if(!cond)
if(Ofs>=BOOT.bs.SectSize)
{
Ofs=0;
sector_in_cluster++;
if(sector_in_cluster >= max_sector_in_this_cluster)
cond=1; // end of cluster
else
{
LOGADR = delay_ +sector_in_cluster+((num_in_fat-2)*BOOT.bs.CS);
if(FATtype!=32) LOGADR += ext_ofs;
logtophys(LOGADR,&ActTrack,&ActHead,&ActSect);
readsector(drive,ActHead,ActTrack,ActSect,sect_buf);
}
}
} //----------// 1 cluster
if(cond==2)
cond2=1;
else
{
if((num_in_fat==0)&&(FATtype!=32))
next_clust=0; // ROOT fat12/16 - 1 cluster.
else
next_clust = FATclst(num_in_fat);
if(next_clust == 0)
cond2=1; // last cluster
else
{
LOGADR = delay_ +((next_clust-2)*BOOT.bs.CS);
if(FATtype!=32) LOGADR += Root1216_Nsectors;
logtophys(LOGADR,&ActTrack,&ActHead,&ActSect);
readsector(drive,ActHead,ActTrack,ActSect,sect_buf);
}
}
} //------------------------// cluster'S
// print_chain(&thisfolder);
// print_chain(&thisfile);
return;
}; //--------------------------------------------------------// end FATFOLDER
void print_chain(RootStruct *x)
{
long clust;
short cond=0;
if(FATtype!=32)
clust = x->begclust;
else
clust = ((long)(x->begclust)&0x0000ffff) + ((long)(x->extclust)<<16);
printf("cluster(s): ");
do
{
printf("%lu;\n",clust);
wait();
if((clust=FATclst(clust)) == 0) cond=1;
else
if(clust==-1) cond=1;
}while(!cond);
}; //----------------------------------------------------// end print chain
|
|
Поиск FAT 
Загрузка ...
