Xreferat.com » Рефераты по информатике и программированию » Розробка програмного забезпечення файлового менеджера

Розробка програмного забезпечення файлового менеджера

действий, обновление списка дисков. Выполняет полное *

* полное обновление, аналогично, как и при запуске программы. *

*******************************************************************************

*/

void __fastcall TForm1::ARefreshListExecute(TObject *Sender)

{

int i, iRetVal, nActive = 0;

char combobuf[64];

PHARDINFO inf;

PLOGICAL_DISC pld;

UCHAR nHDD=0;

CBDiskName->Items->Clear();

CBDiskName2->Items->Clear();

while(inf = hdd[nHDD] = Init(nHDD))

{

pld = inf->disklist;

while(pld)

{

if(pld->nDisc=='?')

goto figoviyDisk;

combobuf[0] = pld->nDisc;

combobuf[1] = ':';

combobuf[2] = 0;

iRetVal = CBDiskName->ItemIndex;

iRetVal = CBDiskName2->ItemIndex;

CBDiskName->Items->Add(combobuf);

CBDiskName2->Items->Add(combobuf);

if(pld->active=='+')

{

nActive = iRetVal;

currpld = pld;

currpld2 = pld;

}

figoviyDisk:

pld =(_LOGICAL_DISC*) pld->next;

}

nHDD++;

}

//ReadDir(currpld,NULL);

//ReadDir2(currpld,NULL);


}


/*******************************************************************************

* При первом показе формы устанавливает текущий диск как индекс значения в *

* списке дисков, это значение всегда используется для получения номера диска. *

*******************************************************************************

*/

void __fastcall TForm1::FormShow(TObject *Sender)

{

CBDiskName2->ItemIndex=0;

Form1->CBDiskName2->OnChange(0);

CBDiskName->ItemIndex=0;

Form1->CBDiskName->OnChange(0);

wsprintf(path,"\");

wsprintf(path2,"\");

}

/*******************************************************************************

* Вывод файлов на панель, функция списка действий *

*******************************************************************************

*/

void __fastcall TForm1::APrintFileListExecute(TObject *Sender)

{

PFILES pfiles;

char sz[128];

char s[2048];

int maxx=0;

pfiles = files;

Form1->Label11->Caption=currpld->cpFS;

Form1->Label12->Caption=currpld->mbLength;

Form1->Label13->Caption=currpld->abs_addr;

Form1->Label14->Caption=currpld->prcfree;

Form1->LBFileList->Items->Clear();

//Form1->LBFileList->Items->SetText("");

while(pfiles)

{

if(pfiles->attrib==8)

{

pfiles =(_FILES*) pfiles->next;

fl=1;

continue;

}

if(pfiles->attrib & FILE_ATTRIBUTE_DIRECTORY){wsprintf(sz,"<DIR>"); dir1++;}

else {wsprintf(sz,"%u",pfiles->filesize); fil1++;}

//if (!strstr("..",pfiles->ansiname )) dir1-=2;

if(pfiles->attrib & FILE_ATTRIBUTE_DIRECTORY)

wsprintf(s,"[%-18s] %#10s %02X",pfiles->ansiname,sz,pfiles->attrib);

else

wsprintf(s,"%-20s %#10s %02X",pfiles->ansiname,sz,pfiles->attrib);

Form1->LBFileList->Items->Add(AnsiString(s));

pfiles =(_FILES*) pfiles->next;

if (strlen(s)>maxx) maxx=strlen(s);

}

Form1->LBFileList->ScrollWidth=maxx*8+10;

Form1->Edit1->Text = Form1->CBDiskName->Text+'\';

//if (strlen(path) > 1) dir1 -= 2;

Form1->Label22->Caption=dir1;

Form1->Label25->Caption=fil1;

}

void __fastcall TForm1::APrintFileListExecute2(TObject *Sender)

{

PFILES pfiles;

char sz[128];

char s[2048];

int maxx=0;

pfiles = files2;

Form1->LBFileList2->Items->Clear();

while(pfiles)

{

if(pfiles->attrib==8)

{

pfiles =(_FILES*) pfiles->next;

continue;

}

if(pfiles->attrib & FILE_ATTRIBUTE_DIRECTORY){wsprintf(sz,"<DIR>"); dir2++;}

else {wsprintf(sz,"%u",pfiles->filesize);/*ltoa((ULONG)pfiles->filesize,sz,10); */fil2++;}

if(pfiles->attrib & FILE_ATTRIBUTE_DIRECTORY)

wsprintf(s,"[%-18s] %#10s %02X",pfiles->ansiname,sz,pfiles->attrib);

else

wsprintf(s,"%-20s %#10s %02X",pfiles->ansiname,sz,pfiles->attrib);

Form1->LBFileList2->Items->Add(AnsiString(s));

pfiles =(_FILES*) pfiles->next;

if (strlen(s)>maxx) maxx=strlen(s);

}

Form1->LBFileList2->ScrollWidth=maxx*8+10;

Form1->Edit2->Text = Form1->CBDiskName2->Text+'\';

//if (strlen(path2) > 1) dir2 -= 2;

Form1->Label27->Caption=dir2;

Form1->Label29->Caption=fil2;

}

*******************************************************************************

* Обработчик изменения имени диска в выпадающем списке вверху. Обновляются все*

* необходимые данные. *

*******************************************************************************

*/

void __fastcall TForm1::CBDiskNameChange(TObject *Sender)

{

LBFileList->Items->Clear();

currpld=FindDiskByChar(*(CBDiskName->Text.SubString(0,1).c_str()));

if(currpld == NULL) return;

ReadDir(currpld,NULL);

wsprintf(path,"\");

CGauge1->Progress=100-currpld->prcfree/(currpld->mbLength/100);

}

void __fastcall TForm1::CBDiskName2Change(TObject *Sender)

{

LBFileList2->Items->Clear();

currpld2=FindDiskByChar(*(CBDiskName2->Text.SubString(0,1).c_str()));

if(currpld2 == NULL) return;

ReadDir2(currpld2,NULL);

wsprintf(path2,"\");

}

/*******************************************************************************

* Обработчик двойного щелчка на области панели с файлами, обрабатываем только *

* бегание по директориям. *

*******************************************************************************

*/

void __fastcall TForm1::LBFileListDblClick(TObject *Sender)

{

int i;

iSelected = LBFileList->ItemIndex;

char *ptr;

char bufferstr[65356];

char buffpath[2048];

PFILES pfirst, pfiles;

if(iSelected == -1)return;

mfile = FindFileByIndex(iSelected);

/*Реагируем только на вход в директорию и на выход из нее */

if((mfile->attrib & 0x10))

if((strlen(path)==1) || ((strlen(path)>1)&&(iSelected>0)))

{

if((strlen(mfile->ansiname)+strlen(path)+3)>sizeof(path))return;

strcat(path, mfile->ansiname);

wsprintf(bufferstr,mfile->ansiname);

strcat(path, "\");

//ReadDir(currpld,path);

if(!ReadDir(currpld,path))

if (strcmp(bufferstr,"..")!=0)

{

ptr = strrchr(path,'\');

while((ptr - path) < strlen(path))

strncpy(ptr,nulpat,strlen(path));

ptr = strrchr(path,'\')+1;

while((ptr - path) < strlen(path))

strncpy(ptr,nulpat,strlen(path));

}

if(strlen(path) == 0) strcat(path, "\");

else if(strlen(path) != 1)

{

if (strcmp(bufferstr,"..")==0)

{

ptr = strrchr(path,'\');

while((ptr - path) < strlen(path))

strncpy(ptr,nulpat,strlen(path));

ptr = strrchr(path,'\');

while((ptr - path) < strlen(path))

strncpy(ptr,nulpat,strlen(path));

ptr = strrchr(path,'\')+1;

while((ptr - path) < strlen(path))

strncpy(ptr,nulpat,strlen(path));

LBFileList->Items->Clear();

ReadDir(currpld,path);

}

}

else

{

LBFileList->Items->Clear();

ReadDir(currpld,NULL);

wsprintf(path,"\");

}

if (strcmp(bufferstr,".")==0)

{

ptr = strrchr(path,'\')-1;

strncpy(ptr,nulpat,strlen(path));

}

Form1->Edit1->Text = Form1->CBDiskName->Text+path;

if (strlen(path) > 1) dir1 -= 2;

// (buffpath,IntToStr(dir1));

Form1->Label22->Caption=dir1;

}

}

//---------------------------------------------------------------------------

void __fastcall TForm1::LBFileList2DblClick(TObject *Sender)

{

int i;

iSelected2 = LBFileList2->ItemIndex;

char *ptr;

char bufferstr[65356];

char buffpath2[2048];

PFILES pfirst, pfiles;

if(iSelected2 == -1)return;

mfile = FindFileByIndex2(iSelected2);

/*Реагируем только на вход в директорию и на выход из нее */

if((mfile->attrib & 0x10))

if((strlen(path2)==1) || ((strlen(path2)>1)&&(iSelected2>0)))

{

if((strlen(mfile->ansiname)+strlen(path2)+3)>sizeof(path2))return;

strcat(path2, mfile->ansiname);

wsprintf(bufferstr,mfile->ansiname);

strcat(path2, "\");

//ReadDir2(currpld2,path2);

if(!ReadDir2(currpld2,path2))

if (strcmp(bufferstr,"..")!=0)

{

ptr = strrchr(path2,'\');

while((ptr - path2) < strlen(path2))

strncpy(ptr,nulpat,strlen(path2));

ptr = strrchr(path2,'\')+1;

while((ptr - path2) < strlen(path2))

strncpy(ptr,nulpat,strlen(path2));

}

if(strlen(path2) == 0) strcat(path2, "\");

else if(strlen(path2) != 1)

{

if (strcmp(bufferstr,"..")==0)

{

ptr = strrchr(path2,'\');

while((ptr - path2) < strlen(path2))

strncpy(ptr,nulpat,strlen(path2));

ptr = strrchr(path2,'\');

while((ptr - path2) < strlen(path2))

strncpy(ptr,nulpat,strlen(path2));

ptr = strrchr(path2,'\')+1;

while((ptr - path2) < strlen(path2))

strncpy(ptr,nulpat,strlen(path2));

LBFileList2->Items->Clear();

ReadDir2(currpld2,path2);

}

}

else

{

LBFileList2->Items->Clear();

ReadDir2(currpld2,NULL);

wsprintf(path2,"\");

}

if (strcmp(bufferstr,".")==0)

{

ptr = strrchr(path2,'\')-1;

strncpy(ptr,nulpat,strlen(path2));

}

Form1->Edit2->Text = Form1->CBDiskName2->Text+path2;

if (strlen(path2) > 1) dir2 -= 2;

// (buffpath,IntToStr(dir1));

Form1->Label27->Caption=dir2;

}

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{

Compare->Visible = false;

Button2->Visible = true;

Button2->SetFocus();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button2Click(TObject *Sender)

{

Compare->Visible = true;

Button2->Visible = false;

Button1->SetFocus();

}

//---------------------------------------------------------------------------

FAT32.CPP

#include <windows.h>

//#include "fat32.h"

#include "err.h"

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Чтение данных раздела

BOOL Fat32DataRead(PDISC_INFO info, char* buf, UINT bufsize)

{

int nRead;

BOOL bRetValue=ReadFile(info->hDrive, buf, bufsize,(unsigned long*) &nRead, NULL);

if(!bRetValue)AnalyzeError("# Error at ReadFile: ",GetLastError());

return bRetValue;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//сдвинуть указатель внутри раздела

UINT Fat32DataMovePointer(PDISC_INFO info, UINT secpointer)

{

UINT iErr;

UINT HiPointer=secpointer>>(32-info->bitsPerSector);

UINT LoPointer=secpointer<<(info->bitsPerSector);


UINT bRetValue=SetFilePointer(info->hDrive,LoPointer,(long*)&HiPointer,FILE_BEGIN);

if(bRetValue==-1)

{

iErr=GetLastError();

if(iErr!=NO_ERROR)AnalyzeError("# Error at SetFilePointer: ",iErr);

}

return bRetValue;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//найти следующий элемент цепочки кластеров

UINT GetNextFileCluster(PDISC_INFO info, UINT nCurrCluster)

{

UINT nextcluster;

if(info->bFAT16)nextcluster = ((USHORT*)(info->pFAT))[nCurrCluster];

else nextcluster = info->pFAT[nCurrCluster];

return nextcluster;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

UINT Cluster2Sector(PDISC_INFO info, UINT cluster)

{

UINT retval;

if(info->bFAT16)

retval = info->sizeReserved+

(info->nFATCopy)*(info->sizeFAT)+

cluster*(info->SectPerCluster);

else

retval = info->sizeReserved+

(info->nFATCopy)*(info->sizeFAT)+

(cluster-2)*(info->SectPerCluster);

return retval;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

char* Fat32ReadFile(PDISC_INFO info, UINT FirstCluster, ULONG* dwFileSize)

{

char* retval = LoadDirectory(info, FirstCluster, dwFileSize);

if(dwFileSize)*dwFileSize = (*dwFileSize)*(info->BytesPerCluster);

return retval;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//пройтись по цепочке кластеров

UINT WalkOnFATTable(PDISC_INFO info, UINT FirstCluster, UINT* LastCluster, UINT* nClusters)

{

UINT fragments=1;

UINT predCluster, n=0;

UINT currCluster=FirstCluster;

while(1)

{

predCluster=currCluster; n++;

currCluster=GetNextFileCluster(info, currCluster);

if(currCluster==0)return 0;

if(currCluster>=0x0FFFFFF8)break;

if(info->bFAT16 && (currCluster>=0xfff8))break;

if(currCluster!=(predCluster+1))fragments++;

}

if(LastCluster)*LastCluster=predCluster;

if(nClusters)*nClusters=n;

return fragments;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Загружает директорию в память

HDIR LoadDirectory(PDISC_INFO info, UINT cluster, ULONG* dirsize)

{

UINT sector,currCluster;

UINT i;

UINT nClusters,dwSize;

HDIR hDir;

char b[1024];

currCluster=cluster;

if(info->bFAT16 && (0 == cluster))

{

nClusters = 1 + (info->nRootElements * 32) / info->BytesPerCluster;

dwSize = nClusters * info->BytesPerCluster;

//MessageBox(0,"zzz","",MB_OK);

}else{

WalkOnFATTable(info,cluster,NULL,&nClusters);

dwSize=(info->BytesPerCluster)*nClusters;

}

hDir=(HDIR)malloc(dwSize);

for(i=0;i<nClusters;i++)

{

if(info->bFAT16 && (0 == cluster))

{

sector = info->RootSector;

}else

sector = Cluster2Sector(info, currCluster);

if(Fat32DataMovePointer(info,sector)==-1)

{

free(hDir);

return NULL;

}

if(!Fat32DataRead(info,hDir+i*(info->BytesPerCluster),info->BytesPerCluster))

{

free(hDir);

return NULL;

}

if(info->bFAT16 && (0 == cluster))

{currCluster++;}

else

{

currCluster = GetNextFileCluster(info,currCluster);

if(currCluster==0)

{

free(hDir);

return NULL;

}

}

if(currCluster>=0x0FFFFFF8)break;

}

//MessageBox(0,"zzz2","",MB_OK);

if(dirsize)*dirsize=nClusters;

return hDir;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Загружает таблицу FAT в память

BOOL LoadFAT(PDISC_INFO info)

{

UINT dwSize=(info->sizeFAT)*(info->nBytePerSector);

if(Fat32DataMovePointer(info,info->beginFAT)==-1)return 0;

info->pFAT=(unsigned int*)malloc(dwSize);

if(info->pFAT==NULL)return FALSE;

if(!Fat32DataRead(info,(char*)(info->pFAT),dwSize))

{

free(info->pFAT);

return FALSE;

}

info->sizeFATbytes=dwSize;

return TRUE;

}


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//если pObjectName==NULL то печатает содержимое директории, находящейся в памяти

//если pObjectName!=NULL ищет в директории директорию с именем pObjectName

UINT ListDirectory(PDISC_INFO info, HDIR hDir,UINT dwDirSize,char* cpObjectName, PFILES* ppfiles)

{

UCHAR attrib;

UCHAR* p;

UCHAR* t;

USHORT firstclusterLo,firstclusterHi;

UINT i,j,h,firstcluster,filesize;

char ansiname[1024];

unsigned char uname[1024];

BOOL IsTheLong=FALSE;

PFILES pfiles, pfirst=NULL, ppred=NULL;

if(hDir==NULL)return 0;

p=hDir; ansiname[11]=0;

for(i=0;i<(dwDirSize*(info->BytesPerCluster))/32;i++)

{

if((p[0]==0xE5) || (p[0] == 0x8F) || (p[11]) == 'b')

{

p=p+32;

continue;

}

if(p[0]==0)break;

attrib=p[11];

if(attrib!=0x0F)

{

firstclusterLo=(*(USHORT*)&p[26]);

firstclusterHi=(*(USHORT*)&p[20]);

firstcluster=firstclusterHi;

firstcluster=(firstcluster<<16)+firstclusterLo;

if(!cpObjectName)

{

filesize=*(UINT*)&p[28];

pfiles =(_FILES*) malloc(sizeof(FILES));

pfiles->attrib = attrib;

pfiles->firstcluster = firstcluster;

pfiles->filesize = filesize;

if(!pfirst)pfirst = pfiles;

if(ppred)ppred->next = pfiles;

}

for(int g=10;g>1;g--)

if(p[g]==' ') p[g]='';

memcpy(ansiname,p,11);

for(j=10;j>1;j--)

if(ansiname[j]!=0x20)

{

ansiname[j+1]=0;

break;

}

if(IsTheLong)

{

WideCharToMultiByte(CP_ACP,0,(LPCWSTR)uname,-1,ansiname,sizeof(ansiname),NULL,NULL);

IsTheLong=FALSE;

}

if(cpObjectName)

if((!strcmpi(cpObjectName,ansiname)) &&

((attrib&0x10)!=0))

return firstcluster;

if(!cpObjectName)

{

pfiles->ansiname =(char*)

malloc(strlen(ansiname)+1);

strcpy(pfiles->ansiname, ansiname);

pfiles->next = NULL;

ppred = pfiles;

}

}

else if((p[0]==1)||(p[0]&0x40))

{

if(p!=(hDir+dwDirSize))

if((p[0]&0x40)&&((p+32)[11]==0x0F))

{

p+=32;

continue;

}

t=p; h=0; memset(uname,0,sizeof(uname));

while(1)

{

j=t[0];

memcpy(uname+h+00,t+1,10);

memcpy(uname+h+10,t+14,12);

memcpy(uname+h+22,t+28,4);

if(j&0x40)

{

IsTheLong=TRUE;

break;

}

t-=32; h+=26;

if(t<hDir)break;

if(t[11]!=0x0F)break;

}

}

p+=32;

}

if(ppfiles)

*ppfiles = pfirst;

return 0;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

double GetFreeSpaceEx(PDISC_INFO info)//

{

unsigned long i;

double RET;

double freeclusters = 0;

double clusters = info->sizeFATbytes / 4;

if (clusters == 0) return 0;

for(i=0;i<clusters;i++)

if(!info->pFAT[i])freeclusters++;


RET=(freeclusters * info->BytesPerCluster);

RET /= (1024*1024);

return RET;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//инициализирует структуру DISC_INFO

PDISC_INFO Fat32Init(char disc)

{

char LogicalDiskName[]="\\.\X:";

char RootDir[]="X:";

UCHAR buf[2048];

UCHAR signature1; //66

USHORT signature2; //510

UCHAR signature3; //38

UINT i,n;

PDISC_INFO info=(_DISC_INFO*)malloc(sizeof(DISC_INFO));

info->Disc=disc;

LogicalDiskName[4]=disc;

RootDir[0]=disc;

info->hDrive=CreateFile(

LogicalDiskName,

GENERIC_READ,

FILE_SHARE_READ | FILE_SHARE_WRITE,

NULL, OPEN_EXISTING, 0, NULL);

if(info->hDrive==INVALID_HANDLE_VALUE)

{

AnalyzeError("# Error at CreateFile: ",GetLastError());

free(info);

return NULL;

}

GetDiskFreeSpace(RootDir,NULL,(unsigned long*)&(info->nBytePerSector),NULL,NULL);

if(!Fat32DataRead(info, buf, info->nBytePerSector))

{

CloseHandle(info->hDrive);

free(info);

return NULL;

}

//bFAT16

signature3=*(UCHAR*)&buf[38];

signature1=*(UCHAR*)&buf[66];

signature2=*(USHORT*)&buf[510];

if(signature2!=0xAA55)

{

//printf("# 55AA sig n'found");

CloseHandle(info->hDrive);

free(info);

return NULL;

}

if((signature3==0x29) && (signature1!=0x29))

{

//printf("YAAHO!! FAT16!!!!!!!!!");

info->bFAT16 = TRUE;

info->sizeFAT = *(short*)&buf[22];

info->nRootElements = *(short*)&buf[17];

}else{

if(signature1 != 0x29)

{

//printf("# unknown FS");

free(info);

return NULL;

}

info->bFAT16 = FALSE;

info->sizeFAT=*(short*)&buf[36];

}

info->nFATCopy=*(short*)&buf[16];

info->sizeReserved=*(short*)&buf[14];

info->SectPerCluster=*(char*)&buf[13];

info->BytesPerCluster=(info->SectPerCluster)*(info->nBytePerSector);

info->beginFAT=info->sizeReserved;

i=info->nBytePerSector; n=0;

while(i=i/2)n++;

info->bitsPerSector=n;

if(!LoadFAT(info))

{

CloseHandle(info->hDrive);

free(info);

return NULL;

}

if(info->bFAT16)

{

info->RootSector = info->beginFAT + info->nFATCopy * info->sizeFAT;

info->RootCluster = 0;

}

else

{

info->RootCluster=*(int*)&buf[44];

info->RootSector = 0;

}

info->hRootDir=LoadDirectory(info, info->RootCluster,&(info->dwRootDirSize));

info->prcfree = GetFreeSpaceEx(info);

return info;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//возвращает кластер директории расположенной по пути cpPath

UINT GotoDir(PDISC_INFO info, char* cpPath)

{

UINT i,dwLen=strlen(cpPath);

char* pStr=(char*)malloc(dwLen+2);

char* cpDirName=pStr;

UINT DirCluster; ULONG dwDirSize;

HDIR hDir;

hDir=info->hRootDir;

dwDirSize=info->dwRootDirSize;

strcpy(pStr,cpPath);

if(pStr[dwLen-1]!='\')

{

strcat(pStr,"\");

dwLen++;

}

for(i=0;i<dwLen;i++)

{

if(pStr[i]=='\')

{

pStr[i]=0;

DirCluster=ListDirectory(info, hDir,dwDirSize,cpDirName, NULL);

if(hDir!=info->hRootDir)free(hDir);

if(!DirCluster)

{

//printf("# error directory %s not found",cpDirName);

free(pStr);

return 0;

}

if(i==(dwLen-1))

{

free(pStr);

return DirCluster;

}

hDir=LoadDirectory(info, DirCluster, &dwDirSize);

cpDirName=pStr+i+1;

}

}

free(pStr);

return 0;

}


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void Fat32DeInit(PDISC_INFO info)

{

free(info->pFAT);

free(info->hRootDir);

CloseHandle(info->hDrive);

free(info);

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

PFILES PrintRootDirectory(PDISC_INFO info)

{

PFILES pfirst = NULL;

ListDirectory(info, info->hRootDir, info->dwRootDirSize, NULL, &pfirst);

return pfirst;

}

MBRMODULE.CPP

#include <windows.h>

//#include "mbrmodule.h"

#include "err.h"

char FAT[]="x01x04x06x0Dx0E";

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Узнать диск по серийному номеру

char GetDiscBySN(UINT SN)

{

UINT VolumeSerialNumber;

char Drive[4]="X:\";

int i;

for(i=2;i<25;i++)

if((GetLogicalDrives()&(1<<i))!=0)

{

Drive[0] = 'A'+i;

switch(GetDriveType(Drive))

{

case DRIVE_CDROM:

break;

default:

GetVolumeInformation(Drive,

NULL,0,

(unsigned long*)&VolumeSerialNumber,

NULL,0,NULL,0

);

if(VolumeSerialNumber==SN)

return Drive[0];

}

}

return 0;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Узнать файловую систему диска по коду файловой системы

char* GetFileSystem(unsigned char code)

{

int i;

if((code==0x07)||(code==0x17))

return "NTFS ";

if(code==0x82)

return "ext2 ";

if(code==0x83)

return "ext3 ";

if((code==0x0B)||(code==0x0C))

return "FAT32 ";

for(i=0;i<sizeof(FAT);i++)

if(code==FAT[i])

return "FAT ";

return "? ";

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//сдвинуть указатель

int MovePointer(PHARDINFO inf, UINT secpointer)

{

UINT iErr;

UINT HiPointer=secpointer>>(32-inf->bitsPerSector);

UINT LoPointer=secpointer<<(inf->bitsPerSector);


UINT bRetValue=SetFilePointer(inf->hDrive,LoPointer,(long*)&HiPointer,FILE_BEGIN);

if(bRetValue==-1)

{

iErr=GetLastError();

if(iErr!=NO_ERROR)

{

//printf("# error at SetFilePointer: ");

AnalyzeError(NULL,iErr);

}

}

return bRetValue;

}


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Читать один сектор с жесткого диска

void* RawRead(PHARDINFO inf)

{

UINT iErr, SectorSize, nRead, i, n;

void* buf;

SectorSize=inf->dwSectorSize;

if(!SectorSize)SectorSize=0x200;

buf=malloc(SectorSize);

while(!ReadFile(inf->hDrive, buf, SectorSize, (unsigned long*)&nRead, NULL))

{

iErr=GetLastError();

free(buf);

if((iErr==ERROR_INVALID_PARAMETER)&&(SectorSize<0x8000))

{

SectorSize=SectorSize*2;

buf=malloc(SectorSize);

continue;

}

//printf("# error at ReadFile: ");

AnalyzeError(NULL,iErr);

return NULL;

};

if(inf->dwSectorSize!=SectorSize)

{

i=SectorSize; n=0;

while(i=i/2)n++;

inf->bitsPerSector=n;

inf->dwSectorSize=SectorSize;

}

return buf;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

/*Изъять серийный номер для FAT или NTFS

abs_addr - адрес начала логического диска в секторах

Serial - адрес 8-байтного буфера для серийного номера

id - идентификатор файловой системы

*/

BOOL GetDiscSerial(PHARDINFO inf, UINT abs_addr, UCHAR* Serial, UCHAR id)

{

char* buf;

int i;

if(MovePointer(inf,abs_addr)==-1)return FALSE;

if((buf=(char*)RawRead(inf))==NULL)return FALSE;

switch(id)

{

case 0x07: //NTFS

memcpy(Serial,buf+72,8);

break;

case 0x0E:

case 0x0C:

case 0x0B: //FAT32

memcpy(Serial,buf+67,4);

break;

default:

for(i=0;i<sizeof(FAT);i++)

if(id==FAT[i])

{

memcpy(Serial,buf+39,4);

free(buf);

return TRUE;

}

return FALSE;

}

free(buf);

return TRUE;

}


/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void DeInit(PHARDINFO inf)

{

CloseHandle(inf->hDrive);

free(inf);

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Вывести список разделов из Partition Table в MBR

PLOGICAL_DISC ListMBR(PHARDINFO inf, UCHAR* pMBR, UINT dwMBRAddr, UINT* pExtended, PPLOGICAL_DISC last)

{

UCHAR* pPart;

UCHAR id,active;

UINT ext=0,secBegin,secLength,mbLength=0,gbLength=0;

PLOGICAL_DISC first=NULL, pld=NULL, pred=NULL;

UINT SectorSize,abs_addr,SN4;

UCHAR SN[8];

char* cpFS;

int i;

SectorSize=inf->dwSectorSize;

pPart=pMBR+0x01BE;

for(i=0;i<4;i++)

{

id=pPart[4];

if(!id)

{

pPart+=0x10;

continue;

}

secBegin=*(UINT*)&pPart[8];

secLength=*(UINT*)&pPart[12];

active=pPart[0];

if(active)active='+';

else active='-';

pPart+=0x10;

mbLength=secLength/(2*1024)*SectorSize/512;

gbLength=mbLength/1024;

abs_addr=dwMBRAddr+secBegin;

cpFS=GetFileSystem(id);

if((id==0x0F)||(id==0x05))

{

ext=secBegin;

continue;

}

memset(SN,0,sizeof(SN));

GetDiscSerial(inf,abs_addr,SN,id);

memcpy(&SN4,SN,4);

pred = pld;

pld =(_LOGICAL_DISC*) malloc(sizeof(LOGICAL_DISC));

memset(pld, 0, sizeof(LOGICAL_DISC));

if(pred!=NULL)

pred->next = pld;

else first = pld;

pld->nHard = inf->nHard;

pld->nDisc = SN4?GetDiscBySN(SN4):'?';

pld->active = active;

pld->abs_addr = abs_addr;

pld->secLength = secLength;

pld->id = id;

pld->cpFS = cpFS;

pld->SN4 = SN4;

pld->gbLength = gbLength;

pld->mbLength = mbLength;

pld->next = NULL;

}

*pExtended = ext;

*last = pld;

return first;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Печатать заголовок

void PrintHead()

{

//printf("HDD Disc Boot Addr Size FS SN mb/gbn");

//printf("------------------------------------------------------------------------n");

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Проверить сигнатуру

BOOL CheckMBR(UCHAR* pMBR)

{

BOOL bRetValue=*(USHORT*)(pMBR+0x01FE)==0xAA55;

// if(!bRetValue)printf("# not valid MBRn");

return bRetValue;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

//Пройтись по цепочке MBR

BOOL WalkOnMBR(PHARDINFO inf, PPLOGICAL_DISC first)

{

PLOGICAL_DISC pred=NULL, last=NULL;

UINT ext,dwNextMBRAddr;

void* pMBR;

*first = NULL;

if((pMBR=RawRead(inf))==NULL)return FALSE;

if(!CheckMBR((unsigned char*)pMBR))

{

free(pMBR);

return FALSE;

}

if((*first=ListMBR(inf,(unsigned char*)pMBR,0,&ext,&last))&&ext)

{

inf->dwExtendedAddr=ext;

ext=0;

while(1)

{

free(pMBR);

dwNextMBRAddr=ext+inf->dwExtendedAddr;

if(MovePointer(inf,dwNextMBRAddr)==-1)return FALSE;

if((pMBR=RawRead(inf))==NULL)return FALSE;

if(!CheckMBR((unsigned char*)pMBR))

{

free(pMBR);

return FALSE;

}

pred = last;

pred->next = ListMBR(inf,(unsigned char*)pMBR,dwNextMBRAddr,&ext,&last);

if(!ext)break;

}

}

free(pMBR);

return TRUE;

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

PHARDINFO Init(char n)

{

char HardDiskName[]="\\.\PHYSICALDRIVE0";

void* hDrive;

UINT iErr, dwSectorSize;

PHARDINFO inf;

HardDiskName[sizeof(HardDiskName)-2]=n+'0';

hDrive=CreateFile(

HardDiskName,

GENERIC_READ,

FILE_SHARE_READ | FILE_SHARE_WRITE,

NULL, OPEN_EXISTING, 0, NULL

);

if(hDrive==INVALID_HANDLE_VALUE)

{

iErr=GetLastError();

if(iErr==ERROR_FILE_NOT_FOUND)return NULL;

AnalyzeError("# Error at CreateFile: ",iErr);

return NULL;

}

inf=(_HARDINFO*)malloc(sizeof(HARDINFO));

inf->hDrive=hDrive;

inf->nHard=n;

inf->dwSectorSize=0;

WalkOnMBR(inf, &inf->disklist);

return inf;}

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: