/* file: mbftRecv.cpp */ #include "mbftpch.h" #include "mbftrecv.hpp" #include "fileio.hpp" #include "messages.hpp" #include "mbftper.h" extern TCHAR s_szMSFT[64]; extern HRESULT GetRecvFolder(LPTSTR pszInFldr, LPTSTR pszOutFldr); extern void OnChangeFolder(void); extern int MyLoadString(UINT idStr, LPTSTR pszDstStr, LPTSTR pszElement); LPTSTR GetRootDirPath(LPTSTR pszDirPath, LPTSTR pszRootDirPath, int nSize); MBFTPrivateReceive::MBFTPrivateReceive ( LPMBFTENGINE lpParentEngine, MBFTEVENTHANDLE EventHandle, T120ChannelID wControlChannel, T120ChannelID wDataChannel ) : MBFTSession(lpParentEngine, EventHandle, MBFT_PRIVATE_RECV_TYPE), m_PrivateMBFTControlChannel(wControlChannel), m_PrivateMBFTDataChannel(wDataChannel), m_MBFTControlSenderID(0), m_MBFTDataSenderID(0), m_ProshareSenderID(0), m_LocalMBFTUserID(0), m_bProshareTransfer(FALSE), m_JoinedToDataChannel(FALSE), m_bOKToLeaveDataChannel(FALSE), m_CurrentReceiveEvent(NULL), m_bEventEndPosted(FALSE), m_CurrentAcceptHandle(0), m_CurrentRejectHandle(0), m_CurrentFileEndHandle(0), m_PreviousRejectState(EnumIdleNotInitialized), m_State(EnumWaitAdmitControlChannel) { m_PrivateMBFTDataChannelList.Append(m_PrivateMBFTDataChannel); } MBFTPrivateReceive::~MBFTPrivateReceive(void) { m_ReceiveList.DeleteAll(); } void MBFTPrivateReceive::JoinControlChannel(void) { if(m_lpParentEngine->MCSChannelJoinRequest(m_PrivateMBFTControlChannel)) { m_State = EnumWaitJoinControlChannel; } else { m_State = EnumInitializationFailed; } } void MBFTPrivateReceive::JoinDataChannel(void) { if(m_lpParentEngine->MCSChannelJoinRequest(m_PrivateMBFTDataChannel)) { if(m_State == EnumWaitAdmitDataChannelIndication) { m_State = EnumWaitJoinDataChannel; } } else { m_State = EnumInitializationFailed; } } BOOL MBFTPrivateReceive::OnMCSChannelJoinConfirm ( T120ChannelID wChannelID, BOOL bSuccess ) { BOOL bReturn = FALSE; if(m_State == EnumWaitJoinControlChannel) { if(wChannelID == m_PrivateMBFTControlChannel) { bReturn = TRUE; m_State = bSuccess ? EnumWaitAdmitDataChannelIndication : EnumInitializationFailed; // data channel admit indication may come earlier than this state change. // look for unserviced channel admit indication if (EnumWaitAdmitDataChannelIndication == m_State) { UINT_PTR chid_uid; m_AdmittedChannelQueue.Reset(); while (0 != (chid_uid = m_AdmittedChannelQueue.Iterate())) { if (m_PrivateMBFTDataChannelList.Find(LOWORD(chid_uid))) { OnMCSChannelAdmitIndication(LOWORD(chid_uid), HIWORD(chid_uid)); m_AdmittedChannelQueue.Remove(chid_uid); break; } } } } } else if(m_State == EnumWaitJoinDataChannel || m_State == EnumWaitRejoinDataChannel) { if(m_PrivateMBFTDataChannelList.Find(wChannelID)) { bReturn = TRUE; if(bSuccess) { m_JoinedToDataChannel = TRUE; if(m_State == EnumWaitJoinDataChannel) { m_State = EnumWaitSendChannelResponsePDU; } else if(m_State == EnumWaitRejoinDataChannel) { TRACERECEIVE(" Rejoined Data Channel [%u]\n",wChannelID); if(m_CurrentReceiveEvent) { SendFileAcceptPDU((unsigned)m_CurrentReceiveEvent->m_hFile); m_CurrentReceiveEvent->m_State = EnumWaitFileStartPDU; } else { TRACE(" *** WARNING: Receive Event deleted before Data Channel was rejoined! ***\n"); } //m_State = EnumWaitFileOfferPDU; } } else { m_State = EnumInitializationFailed; } } } return(bReturn); } void MBFTPrivateReceive::UnInitialize ( BOOL bIsShutDown ) { if(m_State != EnumWaitForTermination) { m_State = EnumWaitForTermination; MBFTReceiveSubEvent * lpReceive; m_ReceiveList.Reset(); while (NULL != (lpReceive = m_ReceiveList.Iterate())) { if(!lpReceive->m_UserAccepted) { lpReceive->m_lpFile->DeleteFile(); } } m_PrivateMBFTDataChannelList.Clear(); if(!bIsShutDown) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostMessage(new DeleteSessionMsg(this)); if(!m_bEventEndPosted) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage( new FileEventEndNotifyMsg(m_EventHandle)); m_bEventEndPosted = TRUE; } } } } MBFTReceiveSubEvent::MBFTReceiveSubEvent ( MBFTFILEHANDLE hFile, LONG FileSize, LPCSTR lpszFileName, time_t FileDateTime, T120UserID SenderID, BOOL bIsBroadcast, BOOL bIsCompressed, BOOL bEOFAcknowledge ) : m_bIsBroadcast(bIsBroadcast), m_hFile(MAKELONG(hFile,SenderID)), m_FileSize(FileSize), m_FileDateTime(FileDateTime), m_TotalBytesReceived(0), m_cbRecvLastNotify(0), m_bFileCompressed(bIsCompressed), m_bEOFAcknowledge(bEOFAcknowledge), m_SenderID(SenderID), m_lpFile(NULL), m_UserAccepted(FALSE) { if(lpszFileName) { ::lstrcpynA(m_szFileName,lpszFileName,sizeof(m_szFileName)); } else { m_szFileName[0] = '\0'; } m_szFileDirectory[0] = '\0'; m_State = (! bIsBroadcast) ? MBFTPrivateReceive::EnumWaitUserConfirmation : MBFTPrivateReceive::EnumWaitFileStartPDU; } BOOL MBFTReceiveSubEvent::Init(void) { DBG_SAVE_FILE_LINE m_lpFile = new CMBFTFile; return(m_lpFile != NULL); } MBFTReceiveSubEvent::~MBFTReceiveSubEvent(void) { if(m_lpFile) { // if the file wasn't completely received, delete it if (m_TotalBytesReceived < m_FileSize) m_lpFile->Close(FALSE); delete m_lpFile; } } BOOL MBFTReceiveSubEvent::IsEqual ( MBFTReceiveSubEvent *lpObject ) { BOOL bReturn = FALSE; if(!lpObject->m_SenderID || !m_SenderID) { bReturn = (lpObject->m_hFile == (MBFTFILEHANDLE)MAKELONG(m_hFile, lpObject->m_SenderID)); } else { bReturn = (lpObject->m_hFile == m_hFile) && (lpObject->m_SenderID == m_SenderID); } return(bReturn); } BOOL MBFTPrivateReceive::OnReceivedFileOfferPDU ( T120ChannelID wChannelID, T120Priority iPriority, T120UserID SenderID, T120NodeID NodeID, LPFILEOFFERPDU lpFileOfferPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_INFORMATIVE_ERROR; if(wChannelID == m_PrivateMBFTControlChannel) { bReturn = TRUE; if(m_State == EnumWaitFileOfferPDU) { // Sanity checking DWORD res; // Windows 95 can't take NULL pointers for these DWORD SecPerCluster, BytePerSector, FreeCluster, TotalFreeCluster; TCHAR szDirPath[MAX_PATH]; TCHAR szRootDirPath[MAX_PATH], *pszRootDir; ::GetRecvFolder(NULL, szDirPath); res = GetFileAttributes(szDirPath); if ((0xffffffff == res)||!(res | FILE_ATTRIBUTE_DIRECTORY)) { // invalid directory name iErrorCode = iMBFT_INVALID_PATH; goto ERRORPROCESS; } pszRootDir = GetRootDirPath(szDirPath, szRootDirPath, MAX_PATH); if (GetDiskFreeSpace(pszRootDir, &SecPerCluster, &BytePerSector, &FreeCluster, &TotalFreeCluster)) { if (!(BytePerSector && SecPerCluster)) { WARNING_OUT(("BytePerSector %d, SecPerCluster %d\n", BytePerSector, SecPerCluster)); } else if ((ULONG)lpFileOfferPDU->GetFileSize()/BytePerSector/SecPerCluster + 1 > FreeCluster) { // not enough space to save the file iErrorCode = iMBFT_DIRECTORY_FULL_ERROR; goto ERRORPROCESS; } } else { ERROR_OUT(("GetDiskSpace Failed, error %d\n", GetLastError())); } BOOL bAckRequired = lpFileOfferPDU->GetAcknowledge(); m_bOKToLeaveDataChannel = bAckRequired; //Change compression handling later -- for now, we assume that a Proshare send is //always compressed.... BOOL bEOFAcknowledge = FALSE; CPeerList *pPeerList = m_lpParentEngine->GetPeerList(); CPeerData *lpPeer; pPeerList->Reset(); while (NULL != (lpPeer = pPeerList->Iterate())) { if(lpPeer->GetUserID() == SenderID) { bEOFAcknowledge = lpPeer->GetEOFAcknowledge(); break; } } DBG_SAVE_FILE_LINE MBFTReceiveSubEvent * lpNewReceive = new MBFTReceiveSubEvent(lpFileOfferPDU->GetFileHandle(), lpFileOfferPDU->GetFileSize(), lpFileOfferPDU->GetFileName(), lpFileOfferPDU->GetFileDateTime(), SenderID, !bAckRequired, lpFileOfferPDU->GetCompressionFlags() & _MBFT_FILE_COMPRESSED, bEOFAcknowledge); if(lpNewReceive) { if(lpNewReceive->Init()) { m_ReceiveList.Append(lpNewReceive); // lonchanc: how can you use static char szTemp[] here??? char szRecvDir[MAX_PATH]; ::GetRecvFolder(NULL, szRecvDir); if(lpNewReceive->m_lpFile->Create(szRecvDir, lpNewReceive->m_szFileName)) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage( new FileOfferNotifyMsg(m_EventHandle, SenderID, NodeID, lpNewReceive->m_hFile, lpNewReceive->m_lpFile->GetFileName(), lpNewReceive->m_FileSize, lpNewReceive->m_FileDateTime, bAckRequired)); } else { iErrorCode = iMBFT_FILE_ACCESS_DENIED; goto ERRORPROCESS; } } else { delete lpNewReceive; } } } else if(m_State == EnumWaitChannelDisband) { SendFileRejectPDU(lpFileOfferPDU->GetFileHandle()); } } return(bReturn); ERRORPROCESS: ReportError(NULL,iErrorType,iErrorCode, TRUE, 0, lpFileOfferPDU->GetFileName(), lpFileOfferPDU->GetFileSize()); SendFileRejectPDU(lpFileOfferPDU->GetFileHandle()); return (bReturn); } BOOL MBFTPrivateReceive::OnReceivedFileStartPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILESTARTPDU lpFileStartPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; MBFTReceiveSubEvent * lpReceiveEvent; MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_INFORMATIVE_ERROR; if (m_PrivateMBFTDataChannelList.Find(wChannelId)) { if(m_State != EnumWaitForTermination && m_State != EnumWaitChannelDisband) { bReturn = TRUE; MBFTReceiveSubEvent TempReceive(lpFileStartPDU->GetFileHandle(),0,NULL,0,SenderID,FALSE,m_bProshareTransfer,FALSE); lpReceiveEvent = m_ReceiveList.FindEquiv(&TempReceive); if(lpReceiveEvent) { if(lpReceiveEvent->m_State == EnumWaitFileStartPDU) { //Double check to make sure.... lpReceiveEvent->m_bFileCompressed = lpFileStartPDU->GetCompressionFlags() & _MBFT_FILE_COMPRESSED; if(lpReceiveEvent->m_bFileCompressed) { // We don't handle compressed files iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } BOOL bSuccess = FALSE; int BytesWritten = 0; if(lpReceiveEvent->m_bFileCompressed) { // We don't handle compressed files iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } else { BytesWritten = lpFileStartPDU->GetDataSize(); if(BytesWritten) { if(!lpReceiveEvent->m_lpFile->Write(lpFileStartPDU->GetDataBuffer(), lpFileStartPDU->GetDataSize())) { iErrorCode = (MBFT_ERROR_CODE)lpReceiveEvent->m_lpFile->GetLastErrorCode(); //iMBFT_FILE_IO_ERROR; } } } //lpReceiveEvent->m_TotalBytesReceived += BytesWritten; lpReceiveEvent->m_TotalBytesReceived = lpReceiveEvent->m_lpFile->Seek(0L,CMBFTFile::SeekMode::SeekFromCurrent); lpReceiveEvent->m_FileSize = lpFileStartPDU->GetFileSize(); if(iErrorCode == iMBFT_OK) { if(m_State != EnumWaitForTermination) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage( new FileTransmitMsg(m_EventHandle, lpReceiveEvent->m_hFile, lpReceiveEvent->m_FileSize, lpReceiveEvent->m_TotalBytesReceived, iMBFT_FILE_RECEIVE_BEGIN, lpReceiveEvent->m_SenderID, lpReceiveEvent->m_bIsBroadcast)); } if(lpFileStartPDU->GetIsEOF()) { lpReceiveEvent->m_lpFile->SetFileDateTime(lpReceiveEvent->m_FileDateTime); lpReceiveEvent->m_lpFile->Close(); lpReceiveEvent->m_State = EnumWaitForTermination; if(lpReceiveEvent->m_bEOFAcknowledge && m_JoinedToDataChannel) { SendFileEndAcknowledgePDU(lpReceiveEvent->m_hFile); } DeleteReceiveEvent(lpReceiveEvent,TRUE); } else { lpReceiveEvent->m_State = EnumWaitFileDataPDU; } } } } //lpReceiveEvent } //m_State != EnumWaitForTermination if(iErrorCode != iMBFT_OK) { BOOL bSendChannelLeave = lpReceiveEvent->m_bEOFAcknowledge; ReportError(lpReceiveEvent,iErrorType,iErrorCode); ReportReceiverError(lpReceiveEvent,iErrorType,iErrorCode); lpReceiveEvent->m_lpFile->Close(FALSE); DeleteReceiveEvent(lpReceiveEvent,TRUE); if(m_bOKToLeaveDataChannel) { if(bSendChannelLeave && m_JoinedToDataChannel) { SendChannelLeavePDU(); } LeaveDataChannel(); } } } //wChannelId == m_PrivateMBFTDataChannel return(bReturn); } void MBFTPrivateReceive::ReportError ( MBFTReceiveSubEvent *lpReceiveEvent, int iErrorType, int iErrorCode, BOOL bIsLocalError, T120UserID SenderID, const char* pFileName, ULONG lFileSize ) { if(m_State != EnumWaitForTermination) { MBFTMsg * lpNewMessage; T120UserID id = SenderID ? SenderID : m_LocalMBFTUserID; DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage( new FileErrorMsg(m_EventHandle, (lpReceiveEvent) ? lpReceiveEvent->m_hFile : 0, iErrorType, iErrorCode, bIsLocalError, id, (lpReceiveEvent) ? lpReceiveEvent->m_bIsBroadcast : 0, pFileName, lFileSize)); } else { TRACERECEIVE(" Waiting for termination, not reporting error"); } } void MBFTPrivateReceive::ReportReceiverError ( MBFTReceiveSubEvent *lpReceive, int iErrorType, int iErrorCode, MBFTFILEHANDLE iFileHandle ) { if(m_State != EnumWaitForTermination) { if(lpReceive) { DBG_SAVE_FILE_LINE FileErrorPDU * lpNewPDU = new FileErrorPDU(iFileHandle ? iFileHandle : lpReceive->m_hFile, iErrorType,iErrorCode); if(lpNewPDU) { if(lpNewPDU->Encode()) { m_lpParentEngine->SendDataRequest(m_MBFTControlSenderID, APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength()); } delete lpNewPDU; } } } else { TRACERECEIVE(" Waiting for termination, not reporting receiver error"); } } void MBFTPrivateReceive::DeleteReceiveEvent ( MBFTReceiveSubEvent *lpReceive, BOOL bNotifyUser ) { if(lpReceive) { if(bNotifyUser) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage( new FileTransmitMsg(m_EventHandle, lpReceive->m_hFile, lpReceive->m_FileSize, lpReceive->m_TotalBytesReceived, iMBFT_FILE_RECEIVE_END, lpReceive->m_SenderID, lpReceive->m_bIsBroadcast)); } m_ReceiveList.Delete(lpReceive); if(m_CurrentReceiveEvent == lpReceive) { m_CurrentReceiveEvent = NULL; } } } BOOL MBFTPrivateReceive::OnReceivedFileDataPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEDATAPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; MBFTReceiveSubEvent * lpReceiveEvent; MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_INFORMATIVE_ERROR; BOOL bLocalError = TRUE; if(m_PrivateMBFTDataChannelList.Find(wChannelId)) { if(m_State != EnumWaitForTermination && m_State != EnumWaitChannelDisband) { bReturn = TRUE; MBFTReceiveSubEvent TempReceive(lpNewPDU->GetFileHandle(),0,NULL,0,SenderID,FALSE,FALSE,FALSE); lpReceiveEvent = m_ReceiveList.FindEquiv(&TempReceive); if(lpReceiveEvent) { if(lpReceiveEvent->m_State == EnumWaitFileDataPDU) { MBFTMsg * lpNewMessage; if(!lpNewPDU->GetIsAbort()) { BOOL bSuccess = FALSE; int BytesWritten = 0; if(lpReceiveEvent->m_bFileCompressed) { // We don't handle compressed files iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } else { BytesWritten = lpNewPDU->GetDataSize(); if(BytesWritten) { if(!lpReceiveEvent->m_lpFile->Write(lpNewPDU->GetDataBuffer(), lpNewPDU->GetDataSize())) { iErrorCode = (MBFT_ERROR_CODE) lpReceiveEvent->m_lpFile->GetLastErrorCode(); //iMBFT_FILE_IO_ERROR; } } } //lpReceiveEvent->m_TotalBytesReceived += BytesWritten; lpReceiveEvent->m_TotalBytesReceived = lpReceiveEvent->m_lpFile->Seek(0L,CMBFTFile::SeekMode::SeekFromCurrent); if(m_State != EnumWaitForTermination) { ASSERT(lpReceiveEvent->m_TotalBytesReceived >= lpReceiveEvent->m_cbRecvLastNotify); ULONG nNotifyDelta = lpReceiveEvent->m_TotalBytesReceived - lpReceiveEvent->m_cbRecvLastNotify; ULONG nNotifyThreshold = lpReceiveEvent->m_FileSize / 100; // 1% if (nNotifyDelta >= nNotifyThreshold || lpReceiveEvent->m_TotalBytesReceived >= lpReceiveEvent->m_FileSize) { DBG_SAVE_FILE_LINE if (S_OK == m_lpParentEngine->SafePostNotifyMessage( new FileTransmitMsg(m_EventHandle, lpReceiveEvent->m_hFile, lpReceiveEvent->m_FileSize, lpReceiveEvent->m_TotalBytesReceived, iMBFT_FILE_RECEIVE_PROGRESS, lpReceiveEvent->m_SenderID, lpReceiveEvent->m_bIsBroadcast))) { lpReceiveEvent->m_cbRecvLastNotify = lpReceiveEvent->m_TotalBytesReceived; } } } if(iErrorCode == iMBFT_OK) { if(lpNewPDU->GetIsEOF()) { lpReceiveEvent->m_lpFile->SetFileDateTime(lpReceiveEvent->m_FileDateTime); lpReceiveEvent->m_lpFile->Close(); lpReceiveEvent->m_State = EnumWaitForTermination; if(lpReceiveEvent->m_bEOFAcknowledge && m_JoinedToDataChannel) { SendFileEndAcknowledgePDU(lpReceiveEvent->m_hFile); } DeleteReceiveEvent(lpReceiveEvent,TRUE); } } } else { ReportError(lpReceiveEvent,MBFT_INFORMATIVE_ERROR,iMBFT_SENDER_ABORTED, FALSE,SenderID); if(!lpReceiveEvent->m_bFileCompressed) { lpReceiveEvent->m_lpFile->Write(lpNewPDU->GetDataBuffer(), lpNewPDU->GetDataSize()); } else { // We don't handle compressed files iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } lpReceiveEvent->m_lpFile->Close(FALSE); lpReceiveEvent->m_State = EnumWaitForTermination; DeleteReceiveEvent(lpReceiveEvent,TRUE); } } } //lpReceiveEvent } //m_State != EnumWaitForTermination if(iErrorCode != iMBFT_OK) { T120UserID id = bLocalError ? m_LocalMBFTUserID : SenderID; ReportError(lpReceiveEvent, iErrorType, iErrorCode, bLocalError, id); if(bLocalError) { ReportReceiverError(lpReceiveEvent,iErrorType,iErrorCode); } if(m_bOKToLeaveDataChannel) { if(lpReceiveEvent->m_bEOFAcknowledge && m_JoinedToDataChannel) { SendChannelLeavePDU(); } LeaveDataChannel(); } DeleteReceiveEvent(lpReceiveEvent,TRUE); } } //wChannelId == m_PrivateMBFTDataChannel return(bReturn); } int MBFTPrivateReceive::DecompressAndWrite ( MBFTReceiveSubEvent *lpReceiveEvent, LPCSTR lpBuffer, LONG BufferLength, LPINT lpDecompressedSize ) { return(iMBFT_MEMORY_ALLOCATION_ERROR); } BOOL MBFTPrivateReceive::OnReceivedFileErrorPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEERRORPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; MBFTReceiveSubEvent TempReceive(lpNewPDU->GetFileHandle(),0,NULL,0,SenderID,FALSE,FALSE,FALSE); MBFTReceiveSubEvent *lpReceiveEvent = m_ReceiveList.FindEquiv(&TempReceive); if(lpReceiveEvent) { bReturn = TRUE; ReportError(lpReceiveEvent,lpNewPDU->GetErrorType(), lpNewPDU->GetErrorCode(), FALSE,SenderID); } else if(m_bProshareTransfer && m_ProshareSenderID == SenderID && lpNewPDU->GetFileHandle() == LOWORD(_iMBFT_PROSHARE_ALL_FILES)) { ReportError(&TempReceive,lpNewPDU->GetErrorType(), lpNewPDU->GetErrorCode(), FALSE,SenderID); bReturn = TRUE; } return(bReturn); } void MBFTPrivateReceive::DoStateMachine(void) { switch(m_State) { case EnumWaitSendChannelResponsePDU: SendChannelResponsePDU(); break; case EnumWaitSendFileAcceptPDU: SendFileAcceptPDU(); break; case EnumWaitSendFileRejectPDU: SendFileRejectPDU(); break; case EnumWaitSendFileEndAcknowledgePDU: SendFileEndAcknowledgePDU(); break; case EnumWaitSendChannelLeavePDU: SendChannelLeavePDU(); break; // caseEnumInitializationFailed: default: break; } } BOOL MBFTPrivateReceive::OnMCSChannelAdmitIndication ( T120ChannelID wChannelId, T120UserID ManagerID ) { BOOL fHandled = FALSE; // // More data channels // if(m_State == EnumWaitFileOfferPDU) { if(m_MBFTDataSenderID == ManagerID) { // // Add the data channel to the list // m_PrivateMBFTDataChannelList.Append(wChannelId); T120ChannelID oldChannel = m_PrivateMBFTDataChannel; m_PrivateMBFTDataChannel = wChannelId; JoinDataChannel(); m_PrivateMBFTDataChannel = oldChannel; fHandled = TRUE; } } else if(m_State == EnumWaitAdmitControlChannel) { if(m_PrivateMBFTControlChannel == wChannelId) { m_MBFTControlSenderID = ManagerID; JoinControlChannel(); fHandled = TRUE; } } else if(m_State == EnumWaitAdmitDataChannelIndication) { if (m_PrivateMBFTDataChannelList.Find(wChannelId)) { m_MBFTDataSenderID = ManagerID; T120ChannelID oldChannel = m_PrivateMBFTDataChannel; m_PrivateMBFTDataChannel = wChannelId; JoinDataChannel(); m_PrivateMBFTDataChannel = oldChannel; fHandled = TRUE; } } if (! fHandled) { UINT chid_uid = MAKELONG(wChannelId, ManagerID); m_AdmittedChannelQueue.Append(chid_uid); } return fHandled; } BOOL MBFTPrivateReceive::OnMCSChannelExpelIndication ( T120ChannelID wChannelId, Reason iReason ) { BOOL bReturn = FALSE; if(/*(wChannelId == m_PrivateMBFTControlChannel) ||*/ m_PrivateMBFTDataChannelList.Find(wChannelId)) { TRACERECEIVE(" Channel [%u] disbanded, terminating receive session\n",wChannelId); //Added by Atul to fix this problem: //If the sender aborts all files, or the send is aborted when the //last file is being sent, the sender sends a FileDataPDU with the ///AbortFlag set to TRUE and proceeds to disband the channel. However, //on account of a MCS bug, the receiver never sees the PDU (sic). //Therefore, when we receive a channel expel indication, we check to //see if we were receiving a file and post a iMBFT_SENDER_ABORTED if necessary... if(m_CurrentReceiveEvent /* && m_bProshareTransfer */ ) { if(m_CurrentReceiveEvent->m_State == EnumWaitFileDataPDU || m_CurrentReceiveEvent->m_State == EnumWaitFileStartPDU) { TRACE(" Unexpected channel disband encountered, posting SENDER_ABORTED message\n"); ReportError(m_CurrentReceiveEvent,MBFT_INFORMATIVE_ERROR,iMBFT_SENDER_ABORTED, FALSE,m_ProshareSenderID); m_CurrentReceiveEvent->m_lpFile->Close(FALSE); m_CurrentReceiveEvent->m_State = EnumWaitForTermination; DeleteReceiveEvent(m_CurrentReceiveEvent,TRUE); } } UnInitialize(); bReturn = TRUE; } m_AdmittedChannelQueue.RemoveByChannelID(wChannelId); return(bReturn); } void MBFTPrivateReceive::SendChannelResponsePDU(void) { if(m_PrivateMBFTControlChannel >= MIN_ASNDynamicChannelID && m_PrivateMBFTControlChannel <= MAX_ASNDynamicChannelID) { T127_PRIVATE_CHANNEL_RESPONSE ChannelJoinResponsePDU; ChannelJoinResponsePDU.pduType = T127_PRIVATE_CHANNEL_JOIN_RESPONSE; ChannelJoinResponsePDU.ControlChannel = SWAPWORD(m_PrivateMBFTControlChannel - MIN_ASNDynamicChannelID); ChannelJoinResponsePDU.Response = (ASNPrivate_Channel_Join_ResponsePDU_result_successful << 5); // if the Mode is FALSE we should use ASNinvitation_rejected if(m_lpParentEngine->SendDataRequest(m_MBFTControlSenderID, APPLET_HIGH_PRIORITY, (LPBYTE)&ChannelJoinResponsePDU, 4)) { TRACERECEIVE(" Sent Channel response PDU on [%u]\n",m_MBFTControlSenderID); m_State = EnumWaitFileOfferPDU; } } else { TRACE(" Receive: Fatal Encoding Failure\n"); m_State = EnumInitializationFailed; //Encoding failed.... } } BOOL MBFTPrivateReceive::SendFileAcceptPDU ( MBFTFILEHANDLE iFileHandle ) { m_State = EnumWaitSendFileAcceptPDU; if(iFileHandle) { m_CurrentAcceptHandle = iFileHandle; } BOOL bReturn = FALSE; DBG_SAVE_FILE_LINE LPFILEACCEPTPDU lpNewPDU = new FileAcceptPDU(m_CurrentAcceptHandle); if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_MBFTControlSenderID, APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { bReturn = TRUE; TRACERECEIVE(" Sent file accept PDU on [%u]\n",m_MBFTControlSenderID); m_State = EnumWaitFileOfferPDU; } } else { ReportError(m_CurrentReceiveEvent,MBFT_PERMANENT_ERROR,iMBFT_ASN1_ENCODING_ERROR); } delete lpNewPDU; } return(bReturn); } void MBFTPrivateReceive::OnControlNotification ( MBFTFILEHANDLE hFile, FileTransferControlMsg::FileTransferControl iControlCommand, LPCSTR lpszDirectory, LPCSTR lpszFileName ) { MBFTReceiveSubEvent * lpReceiveEvent = NULL; MBFTFILEHANDLE iFileHandle; BOOL bAbortHack = FALSE; if(m_State != EnumWaitChannelDisband && m_State != EnumWaitForTermination) { MBFTReceiveSubEvent TempReceive(hFile,0,NULL,0,0,FALSE,FALSE,FALSE); lpReceiveEvent = m_ReceiveList.FindEquiv(&TempReceive); if(lpReceiveEvent) { iFileHandle = (MBFTFILEHANDLE)lpReceiveEvent->m_hFile; if(iControlCommand == FileTransferControlMsg::EnumAcceptFile) { if(lpReceiveEvent->m_State == EnumWaitUserConfirmation) { ::lstrcpynA(lpReceiveEvent->m_szFileDirectory,lpszDirectory, sizeof(lpReceiveEvent->m_szFileDirectory)); int Length = ::lstrlenA(lpReceiveEvent->m_szFileDirectory); if(Length >= 3) { PCHAR pch = SzFindLastCh(lpReceiveEvent->m_szFileDirectory, '\\'); if ('\0' == *(pch+1)) { lpReceiveEvent->m_szFileDirectory[Length - 1] = '\0'; } } if (::lstrlenA(lpszFileName)) { ::lstrcpynA(lpReceiveEvent->m_szFileName, lpszFileName, sizeof(lpReceiveEvent->m_szFileName)); } TRACERECEIVE(" File accept notification for [%u]\n",iFileHandle); lpReceiveEvent->m_UserAccepted = TRUE; m_CurrentReceiveEvent = lpReceiveEvent; if(m_JoinedToDataChannel) { SendFileAcceptPDU(iFileHandle); lpReceiveEvent->m_State = EnumWaitFileStartPDU; } else { m_State = EnumWaitRejoinDataChannel; //m_CurrentReceiveEvent = lpReceiveEvent; JoinDataChannel(); } } } else if(iControlCommand == FileTransferControlMsg::EnumRejectFile) { if((lpReceiveEvent->m_State == EnumWaitUserConfirmation) || (lpReceiveEvent->m_bIsBroadcast && lpReceiveEvent->m_State == EnumWaitFileStartPDU)) { if(hFile == _iMBFT_PROSHARE_ALL_FILES) { iFileHandle = LOWORD(_iMBFT_PROSHARE_ALL_FILES); } TRACERECEIVE(" Rejecting file [%u]\n",lpReceiveEvent->m_hFile); if(m_bOKToLeaveDataChannel) { LeaveDataChannel(); } SendFileRejectPDU(iFileHandle); if(hFile == _iMBFT_PROSHARE_ALL_FILES) { TerminateReceiveSession(); } else { DeleteReceiveEvent(lpReceiveEvent,FALSE); } } } else if(iControlCommand == FileTransferControlMsg::EnumAbortFile) { if(hFile == _iMBFT_PROSHARE_ALL_FILES) { iFileHandle = LOWORD(_iMBFT_PROSHARE_ALL_FILES); } if((lpReceiveEvent->m_State == EnumWaitFileDataPDU) || (lpReceiveEvent->m_State == EnumWaitFileStartPDU) || (hFile == _iMBFT_PROSHARE_ALL_FILES)) { TRACERECEIVE(" Aborting file [%u]\n",iFileHandle); if(lpReceiveEvent->m_State == MBFTPrivateReceive::EnumWaitUserConfirmation) { TRACERECEIVE(" Rejecting file [%u]\n",lpReceiveEvent->m_hFile); SendFileRejectPDU(iFileHandle); } else { if(hFile == _iMBFT_PROSHARE_ALL_FILES) { //If the AbortHack flag is set, we are on a sticky wicket. //We have already aborted the current file and are waiting //for another file offer. Therefore we don't inform the sender //about this one... if(!bAbortHack) { ReportReceiverError(lpReceiveEvent, MBFT_PERMANENT_ERROR, iMBFT_RECEIVER_ABORTED, iFileHandle); } } else { ReportReceiverError(lpReceiveEvent, MBFT_PERMANENT_ERROR, iMBFT_RECEIVER_ABORTED); } } ReportError(lpReceiveEvent,MBFT_INFORMATIVE_ERROR,iMBFT_RECEIVER_ABORTED); if(m_bOKToLeaveDataChannel) { if(lpReceiveEvent->m_bEOFAcknowledge && m_JoinedToDataChannel) { SendChannelLeavePDU(); } LeaveDataChannel(); } if(hFile != _iMBFT_PROSHARE_ALL_FILES) { DeleteNotificationMessages(iMBFT_FILE_RECEIVE_PROGRESS); lpReceiveEvent->m_lpFile->Close(FALSE); // lpReceiveEvent->m_lpFile->DeleteFile(); DeleteReceiveEvent(lpReceiveEvent,TRUE); } else if(m_CurrentReceiveEvent) { m_CurrentReceiveEvent->m_lpFile->Close(FALSE); // m_CurrentReceiveEvent->m_lpFile->DeleteFile(); DeleteReceiveEvent(m_CurrentReceiveEvent,TRUE); } } if(hFile == _iMBFT_PROSHARE_ALL_FILES) { DeleteNotificationMessages(iMBFT_FILE_RECEIVE_PROGRESS); DeleteNotificationMessages(iMBFT_FILE_OFFER); TerminateReceiveSession(); } } } } } void MBFTPrivateReceive::DeleteNotificationMessages ( MBFT_NOTIFICATION iNotificationType ) { #if 0 // lonchanc: no way we can delete notify messages which are already in the queue MBFTMsg * lpNewMessage; CMsgQueue *pNotifyMsgList = m_lpParentEngine->GetNotificationMsgList(); CMsgQueue DeleteList; pNotifyMsgList->Reset(); while (NULL != (lpNewMessage = pNotifyMsgList->Iterate())) { switch (lpNewMessage->GetMsgType()) { case EnumFileTransmitMsg: { FileTransmitMsg *lpFileMsg = (FileTransmitMsg *)lpNewMessage; if(lpFileMsg->m_EventHandle == m_EventHandle) { if(iNotificationType == lpFileMsg->m_TransmitStatus) { TRACERECEIVE(" NUKING Notification [%x] from Event [%ld], Handle: [%ld] FileSize: [%ld], Bytes Xfered[%ld]\n", lpFileMsg->m_TransmitStatus,lpFileMsg->m_EventHandle, lpFileMsg->m_hFile, lpFileMsg->m_FileSize, lpFileMsg->m_BytesTransmitted); DeleteList.Append(lpNewMessage); } } } break; case EnumFileOfferNotifyMsg: { FileOfferNotifyMsg *lpFileOfferMsg = (FileOfferNotifyMsg *)lpNewMessage; if(lpFileOfferMsg->m_EventHandle == m_EventHandle) { if(iNotificationType == iMBFT_FILE_OFFER) { TRACERECEIVE(" NUKING File Offer Notification for [%s], Event: [%ld], Size: [%ld], Handle [%Fp]\n", lpFileOfferMsg->m_szFileName,lpFileOfferMsg->m_EventHandle, lpFileOfferMsg->m_FileSize,lpFileOfferMsg->m_hFile); DeleteList.Append(lpNewMessage); } } } break; default: ASSERT(0); break; } // switch } //for loop // remove handled messages pNotifyMsgList->DeleteSubset(&DeleteList); #endif // 0 } void MBFTPrivateReceive::SendFileRejectPDU ( MBFTFILEHANDLE iFileHandle ) { if(m_State != EnumWaitSendFileRejectPDU) { m_PreviousRejectState = m_State; m_State = EnumWaitSendFileRejectPDU; } if(iFileHandle) { m_CurrentRejectHandle = iFileHandle; } FileRejectPDU * lpNewPDU = NULL; DBG_SAVE_FILE_LINE lpNewPDU = new FileRejectPDU(m_CurrentRejectHandle); if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_MBFTControlSenderID, APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { m_State = (m_PreviousRejectState != EnumWaitChannelDisband) ? EnumWaitFileOfferPDU : EnumWaitChannelDisband; } } else { ReportError(m_CurrentReceiveEvent,MBFT_PERMANENT_ERROR,iMBFT_ASN1_ENCODING_ERROR); } } delete lpNewPDU; } void MBFTPrivateReceive::SendFileEndAcknowledgePDU ( MBFTFILEHANDLE iFileHandle ) { if(iFileHandle) { m_CurrentFileEndHandle = LOWORD(iFileHandle); } m_State = EnumWaitSendFileEndAcknowledgePDU; DBG_SAVE_FILE_LINE FileEndAcknowledgeStruct * lpNewStruct = new FileEndAcknowledgeStruct; lpNewStruct->m_FileHandle = m_CurrentFileEndHandle; DBG_SAVE_FILE_LINE NonStandardPDU * lpNewPDU = new NonStandardPDU(NULL, PROSHARE_FILE_END_STRING, lpNewStruct, sizeof(FileEndAcknowledgeStruct)); if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_PrivateMBFTControlChannel, APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { TRACERECEIVE( " Sent FileEndAcknowledgePDU for [%u] on [%u]\n",m_CurrentFileEndHandle,m_PrivateMBFTControlChannel); m_State = EnumWaitFileOfferPDU; } } else { ReportError(m_CurrentReceiveEvent,MBFT_PERMANENT_ERROR,iMBFT_ASN1_ENCODING_ERROR); } delete lpNewPDU; } delete lpNewStruct; } void MBFTPrivateReceive::SendChannelLeavePDU(void) { m_State = EnumWaitSendChannelLeavePDU; DBG_SAVE_FILE_LINE ChannelLeaveStruct * lpNewStruct = new ChannelLeaveStruct; lpNewStruct->m_ChannelID = m_PrivateMBFTDataChannel; lpNewStruct->m_ErrorCode = iMBFT_RECEIVER_ABORTED; DBG_SAVE_FILE_LINE NonStandardPDU * lpNewPDU = new NonStandardPDU(NULL, PROSHARE_CHANNEL_LEAVE_STRING, lpNewStruct, sizeof(ChannelLeaveStruct)); if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_PrivateMBFTControlChannel, APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { TRACERECEIVE( " Sent ChannelLeavePDU for [%u] on [%u]\n",m_PrivateMBFTDataChannel,m_PrivateMBFTControlChannel); m_State = EnumWaitFileOfferPDU; } } else { ReportError(m_CurrentReceiveEvent,MBFT_PERMANENT_ERROR,iMBFT_ASN1_ENCODING_ERROR); } delete lpNewPDU; } delete lpNewStruct; } void MBFTPrivateReceive::LeaveDataChannel(void) { if(m_JoinedToDataChannel) { if(m_lpParentEngine->MCSChannelLeaveRequest(m_PrivateMBFTDataChannel)) { TRACERECEIVE(" Left data channel\n"); m_JoinedToDataChannel = FALSE; } } } void MBFTPrivateReceive::TerminateReceiveSession(void) { //if(m_lpParentEngine->MCSChannelLeaveRequest(m_PrivateMBFTControlChannel)) //{ //TRACERECEIVE(" Left control channel\n"); //} //Keep the clients happy.... if(!m_bEventEndPosted) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage(new FileEventEndNotifyMsg(m_EventHandle)); m_bEventEndPosted = TRUE; } LeaveDataChannel(); m_State = EnumWaitChannelDisband; //UnInitialize(); } void MBFTPrivateReceive::OnPeerDeletedNotification ( CPeerData *lpPeerData ) { if(m_bProshareTransfer) { if(m_ProshareSenderID == lpPeerData->GetUserID()) { if(m_CurrentReceiveEvent) { if((m_CurrentReceiveEvent->m_State == EnumWaitFileDataPDU) || (m_CurrentReceiveEvent->m_State == EnumWaitFileStartPDU)) { ReportError(m_CurrentReceiveEvent,MBFT_INFORMATIVE_ERROR,iMBFT_SENDER_ABORTED, FALSE,m_ProshareSenderID); m_CurrentReceiveEvent->m_lpFile->Close(FALSE); m_CurrentReceiveEvent->m_State = EnumWaitForTermination; DeleteReceiveEvent(m_CurrentReceiveEvent,TRUE); } } DeleteNotificationMessages(iMBFT_FILE_RECEIVE_PROGRESS); DeleteNotificationMessages(iMBFT_FILE_OFFER); TerminateReceiveSession(); } } } #ifdef USE_BROADCAST_RECEIVE MBFTBroadcastReceive::MBFTBroadcastReceive ( LPMBFTENGINE lpParentEngine, MBFTEVENTHANDLE EventHandle, T120ChannelID wControlChannel, T120ChannelID wDataChannel, T120UserID SenderID, MBFTFILEHANDLE FileHandle ) : MBFTPrivateReceive(lpParentEngine, EventHandle, wControlChannel, wDataChannel), m_SenderID(SenderID), m_FileHandle(FileHandle) { m_MBFTControlSenderID = m_SenderID; m_State = MBFTPrivateReceive::EnumWaitFileOfferPDU; } BOOL MBFTBroadcastReceive::OnReceivedFileOfferPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, T120NodeID NodeID, LPFILEOFFERPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; if(m_State == MBFTPrivateReceive::EnumWaitFileOfferPDU) { bReturn = (wChannelId == m_PrivateMBFTControlChannel) && (lpNewPDU->GetFileHandle() == m_FileHandle) && (SenderID == m_SenderID); if(bReturn) { MBFTPrivateReceive::OnReceivedFileOfferPDU(wChannelId, iPriority, SenderID, NodeID, lpNewPDU, IsUniformSendData); m_CurrentReceiveEvent = m_ReceiveList.PeekHead(); if(m_CurrentReceiveEvent) { ::lstrcpyA(m_CurrentReceiveEvent->m_szFileName,lpNewPDU->GetFileName()); if(!lpNewPDU->GetAcknowledge()) { m_State = m_CurrentReceiveEvent->m_State = MBFTPrivateReceive::EnumWaitFileStartPDU; } else { m_State = m_CurrentReceiveEvent->m_State = MBFTPrivateReceive::EnumWaitUserConfirmation; } } else { UnInitialize(); //m_State = MBFTPrivateReceive::EnumWaitForTermination; } } } return(bReturn); } BOOL MBFTBroadcastReceive::OnMCSChannelJoinConfirm ( T120ChannelID wChannelId, BOOL bSuccess ) { BOOL bReturn = FALSE; if(m_State == MBFTPrivateReceive::EnumWaitJoinDataChannel && m_PrivateMBFTDataChannelList.Find(wChannelId)) { bReturn = TRUE; m_JoinedToDataChannel = TRUE; if(bSuccess && m_CurrentReceiveEvent) { m_State = MBFTPrivateReceive::EnumWaitSendFileAcceptPDU; } else { //m_State = MBFTPrivateReceive::EnumWaitForTermination; LeaveDataChannel(); UnInitialize(); } } return(bReturn); } BOOL MBFTBroadcastReceive::OnReceivedFileStartPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILESTARTPDU lpFileStartPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; if(m_State == MBFTPrivateReceive::EnumWaitFileStartPDU && m_CurrentReceiveEvent) { bReturn = m_PrivateMBFTDataChannelList.Find(wChannelId) && (lpFileStartPDU->GetFileHandle() == m_FileHandle) && (SenderID == m_SenderID); if(bReturn) { if(!lstrlen(m_CurrentReceiveEvent->m_szFileName)) { lstrcpy(m_CurrentReceiveEvent->m_szFileName,lpFileStartPDU->GetFileName()); } if(!lstrlen(m_CurrentReceiveEvent->m_szFileDirectory)) { lstrcpy(m_CurrentReceiveEvent->m_szFileDirectory,m_CurrentReceiveEvent->m_lpFile->GetTempDirectory()); } MBFTPrivateReceive::OnReceivedFileStartPDU(wChannelId, iPriority, SenderID, lpFileStartPDU, IsUniformSendData); //Assumption: m_CurrentReceiveEvent == NULL indicates an error. if(!m_CurrentReceiveEvent || lpFileStartPDU->GetIsEOF()) { //m_State = MBFTPrivateReceive::EnumWaitForTermination; UnInitialize(); } else { m_State = m_CurrentReceiveEvent->m_State = MBFTPrivateReceive::EnumWaitFileDataPDU; } } } return(bReturn); } BOOL MBFTBroadcastReceive::OnReceivedFileDataPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEDATAPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; if(m_State == MBFTPrivateReceive::EnumWaitFileDataPDU && m_CurrentReceiveEvent) { bReturn = m_PrivateMBFTDataChannelList.Find(wChannelId) && (lpNewPDU->GetFileHandle() == m_FileHandle) && (SenderID == m_SenderID); if(bReturn) { MBFTPrivateReceive::OnReceivedFileDataPDU(wChannelId, iPriority, SenderID, lpNewPDU, IsUniformSendData); if(!m_CurrentReceiveEvent || lpNewPDU->GetIsEOF()) { //m_State = MBFTPrivateReceive::EnumWaitForTermination; //LeaveDataChannel(); UnInitialize(); } } } return(bReturn); } void MBFTBroadcastReceive::UnInitialize ( BOOL bIsShutDown ) { if(m_State != EnumWaitForTermination) { m_State = EnumWaitForTermination; if(!bIsShutDown) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostMessage(new DeleteSessionMsg(this)); if(!m_bEventEndPosted) { DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage(new FileEventEndNotifyMsg(m_EventHandle)); m_bEventEndPosted = TRUE; } } } } void MBFTBroadcastReceive::DoStateMachine(void) { if(m_State == MBFTPrivateReceive::EnumWaitSendFileAcceptPDU) { if(m_CurrentReceiveEvent) { if(SendFileAcceptPDU(m_FileHandle)) { m_State = m_CurrentReceiveEvent->m_State = MBFTPrivateReceive::EnumWaitFileStartPDU; } } else { //m_State = MBFTPrivateReceive::EnumWaitForTermination; UnInitialize(); } } } void MBFTBroadcastReceive::OnControlNotification ( MBFTFILEHANDLE hFile, FileTransferControlMsg::FileTransferControl iControlCommand, LPCSTR lpszDirectory, LPCSTR lpszFileName ) { if(m_State != MBFTPrivateReceive::EnumWaitForTermination) { if(m_CurrentReceiveEvent) { MBFTFILEHANDLE iFileHandle = (MBFTFILEHANDLE) m_CurrentReceiveEvent->m_hFile; if(iControlCommand == FileTransferControlMsg::EnumAcceptFile) { if(m_CurrentReceiveEvent->m_State == MBFTPrivateReceive::EnumWaitUserConfirmation) { ::lstrcpynA(m_CurrentReceiveEvent->m_szFileDirectory,lpszDirectory, sizeof(m_CurrentReceiveEvent->m_szFileDirectory)); int Length = ::lstrlenA(m_CurrentReceiveEvent->m_szFileDirectory); if(Length >= 3) { PCHAR pch = SzFindLastCh(m_CurrentReceiveEvent->m_szFileDirectory, '\\'); if ('\0' == *(pch+1)) { m_CurrentReceiveEvent->m_szFileDirectory[Length - 1] = '\0'; } } if (::lstrlenA(lpszFileName)) { ::lstrcpynA(m_CurrentReceiveEvent->m_szFileName, lpszFileName, sizeof(m_CurrentReceiveEvent->m_szFileName)); } TRACERECEIVE(" File accept notification for [%u]\n",iFileHandle); m_CurrentReceiveEvent->m_UserAccepted = TRUE; JoinDataChannel(); m_State = MBFTPrivateReceive::EnumWaitJoinDataChannel; } } #if 0 else if(iControlCommand == FileTransferControlMsg::EnumRejectFile) { if((m_CurrentReceiveEvent->m_State == MBFTPrivateReceive::EnumWaitUserConfirmation)) { LeaveDataChannel(); SendFileRejectPDU(iFileHandle); DeleteReceiveEvent(m_CurrentReceiveEvent,FALSE); UnInitialize(); } } #endif else if((iControlCommand == FileTransferControlMsg::EnumAbortFile) || (iControlCommand == FileTransferControlMsg::EnumRejectFile)) { if((m_CurrentReceiveEvent->m_State == MBFTPrivateReceive::EnumWaitFileDataPDU) || (m_CurrentReceiveEvent->m_State == MBFTPrivateReceive::EnumWaitFileStartPDU) || (m_CurrentReceiveEvent->m_State == EnumWaitUserConfirmation)) { TRACERECEIVE(" Aborting file [%u]\n",iFileHandle); if(m_CurrentReceiveEvent->m_State == MBFTPrivateReceive::EnumWaitUserConfirmation) { //LeaveDataChannel(); SendFileRejectPDU(iFileHandle); //DeleteReceiveEvent(m_CurrentReceiveEvent,FALSE); //UnInitialize(); } else { ReportReceiverError(m_CurrentReceiveEvent, MBFT_PERMANENT_ERROR, iMBFT_RECEIVER_ABORTED); } ReportError(m_CurrentReceiveEvent,MBFT_INFORMATIVE_ERROR,iMBFT_RECEIVER_ABORTED); LeaveDataChannel(); DeleteNotificationMessages(iMBFT_FILE_RECEIVE_PROGRESS); m_CurrentReceiveEvent->m_lpFile->Close(FALSE); DeleteReceiveEvent(m_CurrentReceiveEvent,TRUE); UnInitialize(); } } } } } void MBFTBroadcastReceive::OnPeerDeletedNotification ( CPeerData *lpPeerData ) { if(lpPeerData->GetUserID() == m_SenderID) { if(m_CurrentReceiveEvent) { if(m_State == MBFTPrivateReceive::EnumWaitFileStartPDU || m_State == MBFTPrivateReceive::EnumWaitFileDataPDU) { ReportError(m_CurrentReceiveEvent,MBFT_INFORMATIVE_ERROR,iMBFT_SENDER_ABORTED, FALSE,m_ProshareSenderID); m_CurrentReceiveEvent->m_lpFile->Close(FALSE); DeleteReceiveEvent(m_CurrentReceiveEvent,TRUE); } DeleteNotificationMessages(iMBFT_FILE_RECEIVE_PROGRESS); UnInitialize(); } } } #endif // USE_BROADCAST_RECEIVE MBFTReceiveSubEvent * CRecvSubEventList::FindEquiv ( MBFTReceiveSubEvent *pEvent ) { MBFTReceiveSubEvent *p; Reset(); while (NULL != (p = Iterate())) { if (p->IsEqual(pEvent)) { return p; } } return NULL; } void CRecvSubEventList::Delete ( MBFTReceiveSubEvent *pEvent ) { if (Remove(pEvent)) { delete pEvent; } } void CRecvSubEventList::DeleteAll(void) { MBFTReceiveSubEvent *p; while (NULL != (p = Get())) { delete p; } } BOOL CChannelUidQueue::RemoveByChannelID(T120ChannelID nChannelID) { UINT_PTR chid_uid; Reset(); while (0 != (chid_uid = Iterate())) { if (LOWORD(chid_uid) == nChannelID) { return Remove(chid_uid); } } return FALSE; } UINT_PTR CChannelUidQueue::FindByChannelID(T120ChannelID nChannelID) { UINT_PTR chid_uid; Reset(); while (0 != (chid_uid = Iterate())) { if (LOWORD(chid_uid) == nChannelID) { return chid_uid; } } return 0; } LPTSTR GetRootDirPath(LPTSTR pszDirPath, LPTSTR pszRootDirPath, int nSize) { ::lstrcpy(pszRootDirPath, pszDirPath); if (pszRootDirPath[0] == TEXT('\\')) { if (pszRootDirPath[1] != TEXT('\\')) { return NULL; } // the path starts with two '\\' BOOL fFirstSlash = FALSE; LPTSTR psz = pszRootDirPath + 2; while (*psz && !(fFirstSlash && *psz == TEXT('\\'))) { if (*psz == TEXT('\\')) { fFirstSlash = TRUE; } psz = ::CharNext(psz); } *psz++ = '\\'; *psz = '\0'; return pszRootDirPath; } // the first char is not a '\\', it could be driver letter followed by ':' if (pszRootDirPath[1] == TEXT(':')) { pszRootDirPath[2] = TEXT('\\'); pszRootDirPath[3] = TEXT('\0'); return pszRootDirPath; } // the second char is not a ':' , must be a sub directory return NULL; }