general.cpp

visual c++ 实例编程

		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;
}