?? general.cpp
字號:
ListView->InsertItem(LVIF_TEXT|LVIF_PARAM, i, LPSTR_TEXTCALLBACK, 0, 0, i, (LPARAM) i);
}
wsprintf(TmpStr, "Current Cluster Number: 0x%08X, Current Sector Number: %lu", BufferFatEntries[gCurrentIndex], FatDrivePacket.RelativeSector);
m_wndStatusBarCtrl->SetText(TmpStr, 1, 0);
m_wndStatusBarCtrl->SetText("", 0, 0);
gbPrevSector = FALSE;
if(gCurrentIndex == (gNumFatEntries-1))
gbNextSector = FALSE;
else
gbNextSector = TRUE;
return;
}
void DisplayFilesFoldersSectors(DRIVEPACKET *TmpDrivePacket)
{
DRIVEPACKET DrivePacket;
char TmpStr[100];
gListViewType = 0;
m_wndStatusBarCtrl->SetText("Wait....", 0, 0);
memcpy(&DrivePacket, TmpDrivePacket, sizeof(DRIVEPACKET));
DRIVEPACKET FatDrivePacket;
memcpy(&FatDrivePacket, TmpDrivePacket, sizeof(DRIVEPACKET));
FatDrivePacket.RelativeSector = DrivePacket.FatRelativeSector;
FatDrivePacket.NumSectors = DrivePacket.NumFatSectors;
if(!LoadSectors(&FatDrivePacket, &CylHeadSect, Buffer)){
FatDrivePacket.RelativeSector += DrivePacket.NumFatSectors;
if(!LoadSectors(&FatDrivePacket, &CylHeadSect, Buffer)){
AfxMessageBox("FAT not accessible!");
return;
}
}
gNumFatEntries = CountFatEntries(FatDrivePacket.StartCluster, FatDrivePacket.FatType, Buffer);
if(!gNumFatEntries)
return;
if(hMemBufferFatEntries){
LocalUnlock(hMemBufferFatEntries);
LocalFree(hMemBufferFatEntries);
}
hMemBufferFatEntries = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, gNumFatEntries*4);
if(hMemBufferFatEntries == NULL){
AfxMessageBox("Fatal Error! Not able to allocate a buffer for FAT Entries!");
return;
}
BufferFatEntries = (LPDWORD) LocalLock(hMemBufferFatEntries);
StoreFatEntries(FatDrivePacket.StartCluster, FatDrivePacket.FatType, BufferFatEntries, gNumFatEntries, Buffer);
gSectorsPerCluster = DrivePacket.SectorsPerCluster;
if(hMemBuffer){
LocalUnlock(hMemBuffer);
LocalFree(hMemBuffer);
}
hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, DrivePacket.SectorsPerCluster * 512);
if(hMemBuffer == NULL){
AfxMessageBox("Fatal Error! Not able to allocate a buffer!");
LocalUnlock(hMemBufferFatEntries);
LocalFree(hMemBufferFatEntries);
return;
}
Buffer = (LPBYTE) LocalLock(hMemBuffer);
gCurrentIndex = 0;
gListViewType = FILES_FOLDERS;
gSectorsPerCluster = DrivePacket.SectorsPerCluster;
DrivePacket.RelativeSector += (BufferFatEntries[gCurrentIndex]-2) * gSectorsPerCluster; //Now load the first cluster of file
DrivePacket.NumSectors = gSectorsPerCluster;
if(!LoadSectors(&DrivePacket, &CylHeadSect, Buffer)){
AfxMessageBox("Cluster not accessible!");
}
DeleteColumns();
ListView->InsertColumn(0, "Offset", LVCFMT_LEFT, 100, 0);
for(int i=0; i<16; i++){
wsprintf(TmpStr, "%02X", i);
ListView->InsertColumn(i+1, TmpStr, LVCFMT_LEFT, 30, i+1);
}
ListView->InsertColumn(i+1, "", LVCFMT_LEFT, 15, i+1);
i++;
for(int j=0; (i-17) < 16; i++, j++){
wsprintf(TmpStr, "%01X", j);
ListView->InsertColumn(i+1, TmpStr, LVCFMT_LEFT, 20, i+1);
}
for(i=0; i<gSectorsPerCluster * 32; i++){
ListView->InsertItem(LVIF_TEXT|LVIF_PARAM, i, LPSTR_TEXTCALLBACK, 0, 0, i, (LPARAM) i);
}
wsprintf(TmpStr, "Current Cluster Number: 0x%08X, Current Sector Number: %lu", BufferFatEntries[gCurrentIndex], DrivePacket.RelativeSector);
m_wndStatusBarCtrl->SetText(TmpStr, 1, 0);
m_wndStatusBarCtrl->SetText("", 0, 0);
gbPrevSector = FALSE;
if(gCurrentIndex == (gNumFatEntries-1))
gbNextSector = FALSE;
else
gbNextSector = TRUE;
}
void DisplaySectors(DRIVEPACKET *DrivePacket)
{
DeleteColumns();
ListView->InsertColumn(0, "Offset", LVCFMT_LEFT, 100, 0);
for(int i=0; i<16; i++){
wsprintf(TmpStr, "%02X", i);
ListView->InsertColumn(i+1, TmpStr, LVCFMT_LEFT, 30, i+1);
}
ListView->InsertColumn(i+1, "", LVCFMT_LEFT, 15, i+1);
i++;
for(int j=0; (i-17) < 16; i++, j++){
wsprintf(TmpStr, "%01X", j);
ListView->InsertColumn(i+1, TmpStr, LVCFMT_LEFT, 20, i+1);
}
gListViewType = SECTORS_DUMP;
gSectorsPerCluster = 1;
if(hMemBuffer){
LocalUnlock(hMemBuffer);
LocalFree(hMemBuffer);
}
hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, 512);
if(hMemBuffer == NULL){
AfxMessageBox("Fatal Error! Not able to allocate a buffer!");
LocalUnlock(hMemBufferFatEntries);
LocalFree(hMemBufferFatEntries);
return;
}
Buffer = (LPBYTE) LocalLock(hMemBuffer);
DisplayOneSector(DrivePacket);
gCurrentIndex = 0;
gbPrevSector = FALSE;
if(gCurrentIndex == (DrivePacket->NumSectors-1))
gbNextSector = FALSE;
else
gbNextSector = TRUE;
memcpy(&gDrivePacket, DrivePacket, sizeof(DRIVEPACKET));
}
void DisplayOneSector(DRIVEPACKET *DrivePacket)
{
DRIVEPACKET TmpDrivePacket;
char TmpStr[100];
memcpy(&TmpDrivePacket, DrivePacket, sizeof(DRIVEPACKET));
TmpDrivePacket.NumSectors = 1;
if(TmpDrivePacket.RelativeSector == 0){
BufferNet = Buffer;
NetEvent = BUFFER_FILL;
memcpy(&gDrivePacket, DrivePacket, sizeof(gDrivePacket));
BytesToFill = DrivePacket->NumSectors * 512;
if(DrivePacket->Net){
NetCall.Function = LOAD_SECTOR;
NetCall.Cylinder = DrivePacket->Cylinder;
NetCall.Drive = DrivePacket->Drive;
NetCall.Head = DrivePacket->Head;
NetCall.Sector = DrivePacket->Sector;
NetCall.NumSectors = DrivePacket->NumSectors;
NetCall.NTRelativeSector = DrivePacket->NTRelativeSector;
NetCall.RelativeSector = DrivePacket->RelativeSector;
NetCall.Flag = DrivePacket->Flag;
send(SocketNum, (char *) &NetCall, sizeof(SECTOR_FUNC), 0);
CallNet();
}
else if(gOSWin95){
if(!(DllThunk32)(TmpDrivePacket.Drive, TmpDrivePacket.Cylinder, TmpDrivePacket.Head, TmpDrivePacket.Sector, TmpDrivePacket.NumSectors, (LPBYTE)Buffer, TmpDrivePacket.NTRelativeSector, TmpDrivePacket.Flag)){
AfxMessageBox("Sector not accessible!");
return;
}
}
else{
__int64 Tmp64 = ((__int64) DrivePacket->NTRelativeSector) * 512;
long TmpVal = Tmp64 & 0xFFFFFFFF;
long TmpValHi = (Tmp64 >> 32);
SetFilePointer(hDisk[DrivePacket->Drive], TmpVal, &TmpValHi, FILE_BEGIN);
TmpVal = 0;
ReadFile(hDisk[DrivePacket->Drive], Buffer, DrivePacket->NumSectors * 512, (DWORD *) &TmpVal, NULL);
if((!TmpVal) && (DrivePacket->Drive < 0x80)){
CloseHandle(hDisk[DrivePacket->Drive]);
char TmpStr[100];
wsprintf(TmpStr, "\\\\.\\%c:", DrivePacket->Drive+'A');
if((hDisk[DrivePacket->Drive]=CreateFile(TmpStr, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING, NULL))==INVALID_HANDLE_VALUE){
return;
}
Tmp64 = (((__int64) DrivePacket->NTRelativeSector) + ((__int64) DrivePacket->RelativeSector)) * 512;
TmpVal = Tmp64 & 0xFFFFFFFF;
TmpValHi = (Tmp64 >> 32);
SetFilePointer(hDisk[DrivePacket->Drive], TmpVal, &TmpValHi, FILE_BEGIN);
TmpVal = 0;
ReadFile(hDisk[DrivePacket->Drive], Buffer, DrivePacket->NumSectors * 512, (DWORD *) &TmpVal, NULL);
}
if(TmpVal != (DrivePacket->NumSectors * 512)){
AfxMessageBox("Boot Record not accessible!");
return;
}
}
}
else{
TmpDrivePacket.RelativeSector += gCurrentIndex;
if(!LoadSectors(&TmpDrivePacket, &CylHeadSect, Buffer)){
AfxMessageBox("Sector not accessible!");
return;
}
}
for(int i=0; i<32; i++){
ListView->InsertItem(LVIF_TEXT|LVIF_PARAM, i, LPSTR_TEXTCALLBACK, 0, 0, i, (LPARAM) i);
}
wsprintf(TmpStr, "Current Sector Number: %lu", TmpDrivePacket.RelativeSector);
m_wndStatusBarCtrl->SetText(TmpStr, 1, 0);
}
void CheckFatForBadCluster(LPBYTE pMemFat, LPDWORD CurrentCluster, WORD FatType)
{
DWORD NextCluster, TmpVal;
while(TRUE){
switch(FatType)
{
case FAT12:
TmpVal = (WORD)pMemFat[((*CurrentCluster)*3)/2]+(WORD)pMemFat[((*CurrentCluster)*3)/2+1]*256;
NextCluster = ((*CurrentCluster) % 2) ? (TmpVal >> 4):(TmpVal & 0xFFF);
if(NextCluster != 0xFF7)
return;
break;
case FAT16:
NextCluster = (WORD)pMemFat[(*CurrentCluster)*2]+(WORD)pMemFat[(*CurrentCluster)*2+1]*256;
if(NextCluster != 0xFFF7)
return;
break;
}
(*CurrentCluster)++;
}
}
DWORD GetNextCluster(DWORD CurrentCluster, WORD FatType, LPBYTE Buffer)
{
if(!(CurrentCluster & 0xFFFFFFF))
return 0;
switch(FatType)
{
case FAT16:
if(CurrentCluster == 0xFFFF)
return 0;
break;
case FAT12:
if(CurrentCluster == 0xFFF)
return 0;
break;
case FAT32:
if((CurrentCluster & 0xFFFFFFF) == 0xFFFFFFF)
return 0;
break;
}
DWORD NextCluster=CurrentCluster;
switch(FatType)
{
case FAT16:
NextCluster = (WORD)Buffer[NextCluster*2]+(WORD)Buffer[NextCluster*2+1]*256;
if((NextCluster == 0xFFF7))
NextCluster = 0xFFFFFFF7;
if(NextCluster == 0xFFFF)
NextCluster = 0xFFFFFFFF;
break;
case FAT12:{
DWORD TmpVal = (WORD)Buffer[(NextCluster*3)/2]+(WORD)Buffer[(NextCluster*3)/2+1]*256;
NextCluster = (NextCluster % 2) ? (TmpVal >> 4):(TmpVal & 0xFFF);
if((NextCluster == 0xFF7))
NextCluster = 0xFFFFFFF7;
if(NextCluster == 0xFFF)
NextCluster = 0xFFFFFFFF;
break;
}
case FAT32:
NextCluster &= 0xFFFFFFF;
NextCluster = (DWORD)Buffer[NextCluster*4]+(((DWORD)Buffer[NextCluster*4+1])<<8) +
(((DWORD)Buffer[NextCluster*4+2])<<16) + (((DWORD)Buffer[NextCluster*4+3])<<24);
NextCluster &= 0xFFFFFFF;
if((NextCluster == 0xFFFFFF7))
NextCluster = 0xFFFFFFF7;
if(NextCluster == 0xFFFFFFF)
NextCluster = 0xFFFFFFFF;
break;
}
return NextCluster;
}
void OccupyFATCluster(DWORD NextCluster, DWORD CurrentFreeCluster, WORD FatType, LPBYTE pFat)
{
WORD TmpVal;
switch(FatType)
{
case FAT12:
TmpVal = (WORD)pFat[(CurrentFreeCluster*3)/2]+(WORD)pFat[(CurrentFreeCluster*3)/2+1]*256;
if(CurrentFreeCluster % 2) {
TmpVal &= 0xF;
TmpVal |= (NextCluster << 4);
}
else{
TmpVal &= 0xF000;
TmpVal |= (NextCluster & 0xFFF);
}
pFat[(CurrentFreeCluster*3)/2] = LOBYTE(TmpVal);
pFat[(CurrentFreeCluster*3)/2+1] = HIBYTE(TmpVal);
FatChanged = TRUE;
break;
case FAT16:
pFat[CurrentFreeCluster*2] = LOBYTE(NextCluster);
pFat[CurrentFreeCluster*2+1] = HIBYTE(NextCluster);
FatChanged = TRUE;
break;
case FAT32:
pFat[CurrentFreeCluster*2] = LOBYTE(NextCluster);
pFat[CurrentFreeCluster*2+1] = HIBYTE(NextCluster);
pFat[CurrentFreeCluster*2+2] = (BYTE) (NextCluster >> 16);
pFat[CurrentFreeCluster*2+3] &= 0xF0;
pFat[CurrentFreeCluster*2+3] |= (BYTE) (NextCluster >> 24);
FatChanged = TRUE;
break;
}
}
void CallNet(void)
{
MSG Msg;
while(!BufferRead){
PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE);
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
BufferRead = FALSE;
}
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -