mainfrm.cpp

visual c++ 实例编程

void CMainFrame::OnUndelete() 
{
	// TODO: Add your command handler code here
	DWORD NumFatEntries;
	HLOCAL hMemTempClust;
	if((gListViewType != FILES_FOLDERS) && (gListViewType != ROOT_DIR) && (gListViewType != SUB_DIR))
		return;
	if(ItsFile)
		return;
	POSITION pos = ListView->GetFirstSelectedItemPosition();
	if(pos == NULL)
		return;
	DRIVEPACKET TmpDP;
	memcpy(&TmpDP, &ParentDrivePacket, sizeof(TmpDP));
	HLOCAL hFat = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE, TmpDP.NumFatSectors*512);
	LPBYTE pMemFat = (LPBYTE) LocalLock(hFat);
	TmpDP.NumSectors = TmpDP.NumFatSectors;
	TmpDP.RelativeSector = TmpDP.FatRelativeSector;
	if(!LoadSectors(&TmpDP, &CylHeadSect, pMemFat)){
		TmpDP.RelativeSector += TmpDP.NumFatSectors;
		if(!LoadSectors(&TmpDP, &CylHeadSect, pMemFat)){
			AfxMessageBox("FATs cannot be read successfully!");
			return;
		}
	}
	m_wndStatusBarCtrl->SetText("Undeleting: Wait....", 0, 0);
	while(pos){
		int IndexOfItem = ListView->GetNextSelectedItem(pos);
		FILEPACKET *FilePacket = (FILEPACKET *) ListView->GetItemData(IndexOfItem);
		if((FilePacket->StartCluster == 0) || (FilePacket->StartCluster == 0xFFFFFFFF))
			continue;
		DWORD FatCluster = GetNextCluster(FilePacket->StartCluster, TmpDP.FatType, pMemFat);
		if(((BYTE)FilePacket->Name[0] != 0xE5)  && (FilePacket->Name[0] != 0x05))
			continue;
		if(FatCluster != 0){
			AfxMessageBox("File Cluster already occupied by another file!!  Undelete not possible!");
			continue;
		}
		DWORD NumFileClust=0, NextCluster=0;
		if(FilePacket->Attributes & ATTR_SUBDIR){
			LocalUnlock(hMemTempClust);
			LocalFree(hMemTempClust);
			hMemTempClust = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, ParentDrivePacket.SectorsPerCluster * 512);
			DIRECTORY *pMemTempClust = (DIRECTORY *) LocalLock(hMemTempClust);
			NextCluster = FilePacket->StartCluster;
			DWORD i=0;
			if(!NextCluster)
				continue;
			while(i == 0){
				DRIVEPACKET TmpDrivePacket;
				DWORD TmpVal=0;
				memcpy(&TmpDrivePacket, &ParentDrivePacket, sizeof(DRIVEPACKET));
				TmpDrivePacket.RelativeSector = ParentDrivePacket.DataAreaSector + ParentDrivePacket.SectorsPerCluster * (NextCluster-2);
				TmpDrivePacket.NumSectors = ParentDrivePacket.SectorsPerCluster;
				if(!LoadSectors(&TmpDrivePacket, &CylHeadSect, (PUCHAR) pMemTempClust))
					AfxMessageBox("Directory cluster not loadable!");
				i = GetNextCluster(++NextCluster, ParentDrivePacket.FatType, pMemFat);
				NumFileClust++;
				for(int j=0; j<(ParentDrivePacket.SectorsPerCluster*512); j+=32){
					if(((BYTE)pMemTempClust->Name[0] == 0xE5) || (pMemTempClust->Name[0] == 0x05) || (pMemTempClust->Name[0] == '.'))
						pMemTempClust++;
					else{
						i=1;			//double break trick
						NumFileClust--;
						break;
					}
				}
			}
		}
		else{
			NumFileClust = FilePacket->Size / (TmpDP.SectorsPerCluster * 512);
			if(NumFileClust && (FilePacket->Size % (TmpDP.SectorsPerCluster * 512)))
				NumFileClust++;
		}
		NumFileClust--;
		NextCluster = FilePacket->StartCluster;
		int i=0;
		FatCluster = GetNextCluster(NextCluster, TmpDP.FatType, pMemFat);
		do{
			if(!NumFileClust)
				break;
			if(FatCluster !=0){
				NextCluster--;
				break;
			}
			OccupyFATCluster(NextCluster+1, NextCluster, TmpDP.FatType, pMemFat);
			NextCluster++;
			FatCluster = GetNextCluster(NextCluster, TmpDP.FatType, pMemFat);
		}while(++i<NumFileClust);
		OccupyFATCluster(0xFFFFFFFF, NextCluster, TmpDP.FatType, pMemFat);
		DRIVEPACKET TmpDrivePacket;
		memcpy(&TmpDrivePacket, &ParentDrivePacket, sizeof(DRIVEPACKET));
		LocalUnlock(hMemBuffer);
		LocalFree(hMemBuffer);
		LocalUnlock(hMemBufferFatEntries);
		LocalFree(hMemBufferFatEntries);
		if(gListViewType != ROOT_DIR){
			NumFatEntries = CountFatEntries(ParentDrivePacket.StartCluster, ParentDrivePacket.FatType, pMemFat);
			if(!NumFatEntries)
				continue;
			hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, NumFatEntries * ParentDrivePacket.SectorsPerCluster * 512);
			if(hMemBuffer == NULL){
				AfxMessageBox("Fatal Error!  Not able to allocate a buffer!");
				LocalUnlock(hMemBufferFatEntries);
				LocalFree(hMemBufferFatEntries);
				return;
			}
			HLOCAL hMemBufferFatEntries = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, NumFatEntries*4);
			if(hMemBufferFatEntries == NULL){
				AfxMessageBox("Fatal Error!  Not able to allocate a buffer for FAT Entries!");
				return;
			}
			BufferFatEntries = (LPDWORD) LocalLock(hMemBufferFatEntries);
			StoreFatEntries(ParentDrivePacket.StartCluster, ParentDrivePacket.FatType, BufferFatEntries, NumFatEntries, Buffer);
			if(!ReadDirBuffer(BufferFatEntries, &TmpDrivePacket, NumFatEntries, Buffer)){
				AfxMessageBox("Not able to fully load the sub-directory");
			}
			LocalUnlock(hMemBuffer);
			Buffer = (LPBYTE) LocalLock(hMemBuffer);
		}
		else{
			hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, ParentDrivePacket.NumSectors * 512);
			if(hMemBuffer == NULL){
				AfxMessageBox("Fatal Error!  Not able to allocate a buffer of memory for root dir!");
				return;
			}
			Buffer = (LPBYTE) LocalLock(hMemBuffer);
			if(!LoadSectors(&TmpDrivePacket, &CylHeadSect, Buffer)){
				AfxMessageBox("Root Directory not fully accessible!");
			}
		}
		DIRECTORY *Direc = (DIRECTORY *) Buffer;
		for(i=0; i<=IndexOfItem; i++, Direc++){
			while((Direc->Attributes == 0x0F) || (Direc->Name[0] == '.'))
				Direc++;
		}
		Direc--;
		Direc->Name[0] = '!';
		if(gListViewType == ROOT_DIR){
			if(!WriteSectors(&TmpDrivePacket, &CylHeadSect, Buffer)){
				AfxMessageBox("Root Directory not fully accessible!");
			}
		}
		else
			if(!WriteDirBuffer(BufferFatEntries, &TmpDrivePacket, NumFatEntries, Buffer))
				AfxMessageBox("Not able to fully write the sub-directory");

	}
	TmpDP.NumSectors = TmpDP.NumFatSectors;
	TmpDP.RelativeSector = TmpDP.FatRelativeSector;
	if(!WriteSectors(&TmpDP, &CylHeadSect, pMemFat)){
		AfxMessageBox("FAT 1 cannot be written successfully!");
	}
	TmpDP.RelativeSector += TmpDP.NumFatSectors;
	if(!WriteSectors(&TmpDP, &CylHeadSect, pMemFat)){
		AfxMessageBox("FAT 2 cannot be written successfully!");
	}
	AfxMessageBox("File(s) undeletion completed!");
	m_wndStatusBarCtrl->SetText("", 0, 0);
	LocalUnlock(hFat);
	LocalFree(hFat);
	LocalUnlock(hMemBuffer);
	LocalFree(hMemBuffer);
	LocalUnlock(hMemBufferFatEntries);
	LocalFree(hMemBufferFatEntries);
}

void CMainFrame::OnRename() 
{
	// TODO: Add your command handler code here
	CRename Crn;
	if(ListView->GetSelectedCount() != 1){
		AfxMessageBox("Only one file can be selected!");
		return;
	}
	if(Crn.DoModal()==IDCANCEL)
		return;
	DWORD NumFatEntries;
	POSITION pos = ListView->GetFirstSelectedItemPosition();
	if(pos == NULL)
		return;
	DRIVEPACKET TmpDP;
	memcpy(&TmpDP, &ParentDrivePacket, sizeof(TmpDP));
	HLOCAL hFat = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE, TmpDP.NumFatSectors*512);
	LPBYTE pMemFat = (LPBYTE) LocalLock(hFat);
	TmpDP.NumSectors = TmpDP.NumFatSectors;
	TmpDP.RelativeSector = TmpDP.FatRelativeSector;
	if(!LoadSectors(&TmpDP, &CylHeadSect, pMemFat)){
		TmpDP.RelativeSector += TmpDP.NumFatSectors;
		if(!LoadSectors(&TmpDP, &CylHeadSect, pMemFat)){
			AfxMessageBox("FATs cannot be read successfully!");
		}
	}
	int IndexOfItem = ListView->GetNextSelectedItem(pos);
	FILEPACKET *FilePacket = (FILEPACKET *) ListView->GetItemData(IndexOfItem);
	DRIVEPACKET TmpDrivePacket;
	memcpy(&TmpDrivePacket, &ParentDrivePacket, sizeof(DRIVEPACKET));
	LocalUnlock(hMemBuffer);
	LocalFree(hMemBuffer);
	LocalUnlock(hMemBufferFatEntries);
	LocalFree(hMemBufferFatEntries);
	if(gListViewType != ROOT_DIR){
		NumFatEntries = CountFatEntries(ParentDrivePacket.StartCluster, ParentDrivePacket.FatType, pMemFat);
		if(!NumFatEntries)
			return;
		hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, NumFatEntries * ParentDrivePacket.SectorsPerCluster * 512);
		if(hMemBuffer == NULL){
			AfxMessageBox("Fatal Error!  Not able to allocate a buffer!");
			LocalUnlock(hMemBufferFatEntries);
			LocalFree(hMemBufferFatEntries);
			return;
		}
		HLOCAL hMemBufferFatEntries = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, NumFatEntries*4);
		if(hMemBufferFatEntries == NULL){
			AfxMessageBox("Fatal Error!  Not able to allocate a buffer for FAT Entries!");
			return;
		}
		BufferFatEntries = (LPDWORD) LocalLock(hMemBufferFatEntries);
		StoreFatEntries(ParentDrivePacket.StartCluster, ParentDrivePacket.FatType, BufferFatEntries, NumFatEntries, Buffer);
		if(!ReadDirBuffer(BufferFatEntries, &TmpDrivePacket, NumFatEntries, Buffer)){
			AfxMessageBox("Not able to fully load the sub-directory");
		}
		LocalUnlock(hMemBuffer);
		Buffer = (LPBYTE) LocalLock(hMemBuffer);
	}
	else{
		hMemBuffer = LocalAlloc(LMEM_MOVEABLE|LMEM_DISCARDABLE|LMEM_ZEROINIT, ParentDrivePacket.NumSectors * 512);
		if(hMemBuffer == NULL){
			AfxMessageBox("Fatal Error!  Not able to allocate a buffer of memory for root dir!");
			return;
		}
		Buffer = (LPBYTE) LocalLock(hMemBuffer);
		if(!LoadSectors(&TmpDrivePacket, &CylHeadSect, Buffer)){
			AfxMessageBox("Root Directory not fully accessible!");
		}
	}
	DIRECTORY *Direc = (DIRECTORY *) Buffer;
	for(int i=0; i<=IndexOfItem; i++, Direc++){
		while((Direc->Attributes == 0x0F) || (Direc->Name[0] == '.'))
			Direc++;
	}
	Direc--;
	memset(Direc->Name, ' ', 11);
	strcpy(Direc->Name, RenFileName);
	Direc->Name[strlen(RenFileName)] = ' ';
	Direc->Extension[0] = RenFileExt[0];
	Direc->Extension[1] = (RenFileExt[1] == 0) ? ' ':RenFileExt[1];
	Direc->Extension[2] = (RenFileExt[2] == 0) ? ' ':RenFileExt[2];
	if(gListViewType == ROOT_DIR){
		if(!WriteSectors(&TmpDrivePacket, &CylHeadSect, Buffer)){
			AfxMessageBox("Root Directory not fully accessible!");
		}
	}
	else
		if(!WriteDirBuffer(BufferFatEntries, &TmpDrivePacket, NumFatEntries, Buffer))
			AfxMessageBox("Not able to fully write the sub-directory");

}

void CMainFrame::OnConnect() 
{
	// TODO: Add your command handler code here
	char TmpStr[100];
	CConnect CC;
	if(CC.DoModal()==IDCANCEL)
		return;

	CSADDR_INFO CSABuf[10];
	DWORD dwCSABufsize = sizeof(CSABuf);
	GUID guidDNS = SVCID_TCP(1026);
	int lpTCP[10] = {IPPROTO_TCP, 0};
	BYTE Buffer[1000];
	DWORD Bytes;
	PPROTOCOL_INFO lpTCPINFO;
	// And create the socket descriptor
	lpTCPINFO = (PPROTOCOL_INFO) Buffer;
	Bytes = sizeof(Buffer);
	EnumProtocols((LPINT) lpTCP, lpTCPINFO, &Bytes);
	GetAddressByName(0,   // Since GUID is name space specific, we don't need to specify
						&guidDNS,  // GUID defined by TCP port number
						NetMachine,  // This parameter is actually not used for RES_SERVICE calls
						NULL,    // GUID implies protocol so no need to specify
						RES_FIND_MULTIPLE,  // Specifies that we are trying to find local address to bind to
						NULL,  // Currently not supported
						CSABuf, // Results buffer
						&dwCSABufsize,   // Size of results buffer
						NULL,    // Not supported
						NULL);    // Not supported
						   // Need at least one address returned in order to bind()
	if ((SocketNum = socket(lpTCPINFO->iAddressFamily,
									   lpTCPINFO->iSocketType,
									   lpTCPINFO->iProtocol)) == SOCKET_ERROR){
	   // ERROR
		AfxMessageBox("Socket creation error");
		return;  // This will reuse the current ServSocks structure
	}
	if (connect(SocketNum,
				CSABuf[0].RemoteAddr.lpSockaddr,
				CSABuf[0].RemoteAddr.iSockaddrLength) == SOCKET_ERROR){
		AfxMessageBox("Error in connect");
		closesocket(SocketNum);
		return;
	}
	if(WSAAsyncSelect(SocketNum,
					  this->m_hWnd,
					 MW_CONNECTED,
				  FD_WRITE|FD_READ) == SOCKET_ERROR){
	   // Error -- cleanup
		AfxMessageBox("Error in WSAAsyncSelect");
		closesocket(SocketNum);
		return;
	}
	sprintf(TmpStr, "Remote - %s", NetMachine);
	DrivePacket->Net = TRUE;
	DrivePacket->Type = NET;
	TvI.mask = TVIF_CHILDREN | TVIF_TEXT | TVIF_PARAM;
	TvI.pszText = TmpStr;
	TvI.cChildren = 1;
	TvI.lParam = (long)DrivePacket;
	TvIns.item = TvI;
	TvIns.hParent = TVI_ROOT;
	TvIns.hInsertAfter = TVI_LAST;
	DrivePacket++;
	hPrevHD = DiskTree->InsertItem((LPTVINSERTSTRUCT) &TvIns);
	NetEvent = SAY_NUM_DISKS;
	BYTE DisksFunc = SAY_NUM_DISKS;
	send(SocketNum, (char *) &DisksFunc, 1, 0);
	CallNet();
}

LRESULT CMainFrame::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
{
	// TODO: Add your specialized code here and/or call the base class
	static int Tmp=0;
	if(message == MW_CONNECTED){
		switch(WSAGETSELECTEVENT(lParam)){
		case FD_READ:
			switch(NetEvent){
			case SAY_NUM_DISKS:
				NUM_DISKS NumDisks;
				BufferRead = FALSE;
				recv(SocketNum, (char *) &NumDisks, sizeof(NUM_DISKS), 0);
				NumFloppiesNet = NumDisks.NumFloppies;
				NumHardsNet = NumDisks.NumHards;
				Int13ExtNet = NumDisks.Int13Extension;
				BufferRead = TRUE;
				break;
			case BUFFER_FILL:
				DWORD TmpVal;
				char TmpStr[100];
//				if((TmpVal = recv(SocketNum, (char *)(BufferNet+Tmp), 1024, 0))==SOCKET_ERROR)
//					if((TmpVal = recv(SocketNum, (char *)(BufferNet+Tmp), 1024, 0))==SOCKET_ERROR)
						if((TmpVal = recv(SocketNum, (char *)(BufferNet+Tmp), 1024, 0))==SOCKET_ERROR){
							recv(SocketNum, (char *)(BufferNet+Tmp), 0, 0);
//							AfxMessageBox("recv Error");
//							wsprintf(TmpStr, "%lu", WSAGetLastError());
//							AfxMessageBox(TmpStr);
							break;
						}
				Tmp += TmpVal;
				if((Tmp-BytesToFill)==0){
					Tmp=0;
					BufferRead = TRUE;
				}
				break;
			}
//			AfxMessageBox("Read notify");
//			if((Tmp = recv(SocketNum, Buffer, i, 0))!= i){
//				while((Tmp+=recv(SocketNum, Buffer+Tmp, i-Tmp, 0)) != i)
//					;
//			Tmp+=recv(SocketNum, BufferTmp+Tmp, i-Tmp, 0);
//		}
//			i++;
//			if((Tmp-i)==0)
//				Read = TRUE;
//			break;
		case FD_WRITE:
			break;
		}
	}
	
	return CFrameWnd::WindowProc(message, wParam, lParam);
}