|
|
/* file: mbftsend.cpp */
#include "mbftpch.h"
#include "mbftsend.hpp"
#include "fileio.hpp"
#include "messages.hpp"
#include "mbftapi.hpp"
#define _MAX_SEND_PACKETS 1
ULONG g_nSendDisbandDelay = 5000; // Previous: Twenty seconds!
ULONG g_nChannelResponseDelay = 60000;
MBFTPrivateSend::MBFTPrivateSend ( LPMBFTENGINE lpParentEngine, MBFTEVENTHANDLE EventHandle, T120ChannelID wMBFTUserID, ULONG MaxDataLength ) : MBFTSession(lpParentEngine, EventHandle, MBFT_PRIVATE_SEND_TYPE), m_PrivateMBFTControlChannel(0), m_PrivateMBFTDataChannel(0),
m_lpUserArray(NULL), m_lpAcceptedUsersArray(NULL),
m_iUserCount(0),
m_MBFTChannelID(wMBFTUserID), m_MaxDataLength(MaxDataLength),
m_LastUserCount(0), m_ResponseCount(0), m_AcceptCount(0), m_RejectCount(0), m_AbortedCount(0), m_AcknowledgeCount(0),
m_CurrentFileSize(0), m_lTotalBytesRead(0), m_lpDataBuffer(NULL),
m_bProshareTransfer(FALSE), m_bEOFAcknowledge(FALSE),
m_lpFile(NULL), m_pszCurrentFilePath(NULL), m_CurrentFileHandle(0), m_AcceptedIndex(0), m_bSentFileOfferPDU(FALSE), m_bUnInitializing(FALSE), m_bAbortAllFiles(FALSE), m_bSendingFile(FALSE), m_bAbortFileSend(FALSE), m_SentFileStartPDU(FALSE), m_TimeOutValue(0), m_bCompressFiles(FALSE), m_bOKToDisbandChannel(TRUE),
m_lpV42bisPointer(NULL), m_bFlushv42Compression(FALSE), m_bEventEndPosted(FALSE),
m_State(EnumIdleNotInitialized) { }
MBFTPrivateSend::~MBFTPrivateSend(void) { delete m_pszCurrentFilePath; delete m_lpUserArray; delete m_lpAcceptedUsersArray; delete m_lpDataBuffer; delete m_lpFile; }
void MBFTPrivateSend::ConveneControlChannel(void) { if(m_lpParentEngine->MCSChannelConveneRequest()) { m_State = EnumWaitConveneControlChannel; } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); } }
void MBFTPrivateSend::ConveneDataChannel(void) { if(m_lpParentEngine->MCSChannelConveneRequest()) { m_State = EnumWaitConveneDataChannel; } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); } }
void MBFTPrivateSend::JoinControlChannel(void) { if(m_lpParentEngine->MCSChannelJoinRequest(m_PrivateMBFTControlChannel)) { m_State = EnumWaitJoinControlChannel; } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); } } BOOL MBFTPrivateSend::OnMCSChannelJoinConfirm ( T120ChannelID wChannelId, BOOL bSuccess ) { BOOL bReturn = FALSE; if(wChannelId == m_PrivateMBFTControlChannel) { if(m_State == EnumWaitJoinControlChannel) { if(bSuccess) { TRACESEND(" Control channel joined [%u]\n",wChannelId);
ConveneDataChannel(); } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); }
bReturn = TRUE; } }
return(bReturn); }
void MBFTPrivateSend::AdmitControlChannel(void) { if(m_lpParentEngine->MCSChannelAdmitRequest(m_PrivateMBFTControlChannel, m_lpUserArray, m_iUserCount)) { TRACESEND(" Admit Control Channel Successful [%u]\n",m_PrivateMBFTControlChannel); } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); }
if(m_lpParentEngine->MCSChannelAdmitRequest(m_PrivateMBFTDataChannel, m_lpUserArray, m_iUserCount)) { TRACESEND(" Admit Data Channel Successful [%u]\n",m_PrivateMBFTDataChannel);
m_State = EnumWaitChannelResponsePDU;
m_TimeOutValue = GetTickCount() + g_nChannelResponseDelay; } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); } }
BOOL MBFTPrivateSend::OnMCSChannelConveneConfirm ( T120ChannelID wChannelId, BOOL bSuccess ) { BOOL bReturn = FALSE;
if(m_State == EnumWaitConveneControlChannel) { if(bSuccess) { TRACESEND(" Control channel convened [%u]\n",wChannelId); m_PrivateMBFTControlChannel = wChannelId; JoinControlChannel(); } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); }
bReturn = TRUE; } else if(m_State == EnumWaitConveneDataChannel) { if(bSuccess) { TRACESEND(" Data channel convened [%u]\n",wChannelId); m_PrivateMBFTDataChannel = wChannelId; m_State = EnumWaitSendChannelInvitePDU; } else { ReportError(MBFT_PERMANENT_ERROR,iMBFT_UNKNOWN_ERROR,TRUE); UnInitialize(); }
bReturn = TRUE; }
return(bReturn); }
BOOL MBFTPrivateSend::SubmitFileSendRequest ( SubmitFileSendMsg *pMsg ) { BOOL bCompressFiles = pMsg->m_bCompressFiles;
delete m_pszCurrentFilePath; // clean up any possible left over
m_pszCurrentFilePath = pMsg->m_pszFilePath; m_CurrentFileHandle = pMsg->m_nFileHandle; pMsg->m_pszFilePath = NULL; // keep this pointer for furure use
MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_PERMANENT_ERROR;
//NOTE: Merely turning this flag to TRUE will NOT
//enable compression. I have set it to FALSE here
//so that certain stubbed routines will not be
//entered. If you turn this flag to TRUE....
//then...have your finger ready on the reset button!!
//If you want to turn compression on, Then you have
//to include a bunch of v42.bis compression files etc.
bCompressFiles = FALSE;
// get the peer list
CPeerList *pPeerList = m_lpParentEngine->GetPeerList();
ASSERT(! (pMsg->m_nUserID && pMsg->m_nNodeID)); BOOL fBroadcast = (0 == pMsg->m_nUserID && 0 == pMsg->m_nNodeID); ULONG iNumNodes = 1; if (fBroadcast) { iNumNodes = pPeerList->GetCount(); ASSERT(iNumNodes); }
DBG_SAVE_FILE_LINE m_lpDataBuffer = new char[m_MaxDataLength + MAX_PATH + _iMBFT_FILEDATA_PDU_SUBTRACT]; // enough space for the largest PDU
DBG_SAVE_FILE_LINE m_lpUserArray = new UserID[iNumNodes]; DBG_SAVE_FILE_LINE m_lpAcceptedUsersArray = new UserID[iNumNodes];
if (NULL == m_lpDataBuffer || NULL == m_lpUserArray || NULL == m_lpAcceptedUsersArray) { ERROR_OUT(("MBFTPrivateSend::SubmitFileSendRequest: allocation failure")); delete m_lpDataBuffer; m_lpDataBuffer = NULL; delete m_lpUserArray; m_lpUserArray = NULL; delete m_lpAcceptedUsersArray; m_lpAcceptedUsersArray = NULL; iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; }
if(iErrorCode == iMBFT_OK) { m_iUserCount = 0;
ZeroMemory(m_lpUserArray, sizeof(UserID) * iNumNodes); ZeroMemory(m_lpAcceptedUsersArray, sizeof(UserID) * iNumNodes);
m_bProshareTransfer = TRUE; m_bEOFAcknowledge = TRUE; if (fBroadcast) { CPeerData *lpPeer; pPeerList->Reset(); while (NULL != (lpPeer = pPeerList->Iterate())) { if (lpPeer->GetUserID() != m_lpParentEngine->GetUserID()) { m_lpUserArray[m_iUserCount++] = lpPeer->GetUserID();
if(m_bProshareTransfer) { m_bProshareTransfer = lpPeer->GetIsProshareNode(); } if(m_bEOFAcknowledge) { m_bEOFAcknowledge = lpPeer->GetEOFAcknowledge(); } } } // while
} else { CPeerData *lpPeer; pPeerList->Reset(); while (NULL != (lpPeer = pPeerList->Iterate())) { if ((pMsg->m_nUserID && pMsg->m_nUserID == lpPeer->GetUserID()) || (pMsg->m_nNodeID && pMsg->m_nNodeID == lpPeer->GetNodeID())) { m_lpUserArray[m_iUserCount++] = lpPeer->GetUserID();
if(m_bProshareTransfer) { m_bProshareTransfer = lpPeer->GetIsProshareNode(); } if(m_bEOFAcknowledge) { m_bEOFAcknowledge = lpPeer->GetEOFAcknowledge(); } break; } } // while
if (NULL == lpPeer) { iErrorCode = iMBFT_RECIPIENT_NOT_FOUND; } }
if(m_bCompressFiles) { iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } else { DBG_SAVE_FILE_LINE m_lpFile = new CMBFTFile; }
if(!m_lpFile) { iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; }
if(iErrorCode == iMBFT_OK) { m_State = EnumFileSendPending; } }
if(iErrorCode != iMBFT_OK) { // LOGERROR(iErrorCode,0,0);
ReportError(iErrorType,iErrorCode,TRUE); TerminateSendSession(); }
return(iErrorCode == iMBFT_OK); }
void MBFTPrivateSend::ReportSenderError ( int iErrorType, int iErrorCode, MBFTFILEHANDLE hFile ) { DBG_SAVE_FILE_LINE FileErrorPDU * lpNewPDU = new FileErrorPDU((hFile) ? LOWORD(hFile) : LOWORD(m_CurrentFileHandle), iErrorType,iErrorCode); if(lpNewPDU) { if(lpNewPDU->Encode()) { for (ULONG Index = 0; Index < m_iUserCount; Index++) { m_lpParentEngine->SendDataRequest(m_lpUserArray[Index], APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength()); } }
delete lpNewPDU; } }
void MBFTPrivateSend::ReportError ( int iErrorType, int iErrorCode, BOOL bIsLocalError, T120UserID SenderID, MBFTFILEHANDLE FileHandle) { T120UserID id = SenderID ? SenderID : m_MBFTChannelID;
DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage( new FileErrorMsg( m_EventHandle, FileHandle ? FileHandle : m_CurrentFileHandle, iErrorType, iErrorCode, bIsLocalError, id)); }
void MBFTPrivateSend::TerminateSendSession(void) { UnInitialize(); } void MBFTPrivateSend::UnInitialize ( BOOL bShutDown ) { BOOL bDataChannelDisbanded = FALSE; BOOL bControlChannelDisbanded = FALSE;
if(m_State != EnumWaitForTermination) { m_State = EnumWaitForTermination;
TRACESEND(" Uninit begin\n");
if (m_bEOFAcknowledge) { m_TimeOutValue = 0; } else { m_TimeOutValue = GetTickCount() + g_nSendDisbandDelay; } TRACESEND(" Using TimeOutValue of %d\n", m_TimeOutValue); }
m_bUnInitializing = TRUE;
if(GetTickCount() >= m_TimeOutValue) { if(m_PrivateMBFTDataChannel) { if(m_lpParentEngine->MCSChannelDisbandRequest(m_PrivateMBFTDataChannel)) { TRACESEND(" Uninit: Data Channel disbanded [%u]\n",m_PrivateMBFTDataChannel); bDataChannelDisbanded = TRUE; m_PrivateMBFTDataChannel = 0; } else if(m_lpParentEngine->GetLastSendDataError() == MCS_TRANSMIT_BUFFER_FULL) { TRACESEND("Transmit buffer for [%u] full, data channel disband failed\n",m_PrivateMBFTDataChannel); } else { TRACESEND("Unexpected error [%u] while disbanding data channel [%u]\n", m_lpParentEngine->GetLastSendDataError(),m_PrivateMBFTDataChannel); } } else { bDataChannelDisbanded = TRUE; }
if(bDataChannelDisbanded) { if(m_PrivateMBFTControlChannel) { if(m_lpParentEngine->MCSChannelDisbandRequest(m_PrivateMBFTControlChannel)) { TRACESEND(" Uninit: Control Channel disbanded [%u]\n",m_PrivateMBFTControlChannel); bControlChannelDisbanded = TRUE; m_PrivateMBFTControlChannel = 0; } else if(m_lpParentEngine->GetLastSendDataError() == MCS_TRANSMIT_BUFFER_FULL) { TRACESEND("Transmit buffer for [%u] full, control channel disband failed\n",m_PrivateMBFTDataChannel); } else { TRACESEND("Unexpected error [%u] while disbanding control channel [%u]\n", m_lpParentEngine->GetLastSendDataError(),m_PrivateMBFTDataChannel); } } else { bControlChannelDisbanded = TRUE; } }
if(!bShutDown) { if(bDataChannelDisbanded && bControlChannelDisbanded) { 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; } TRACESEND(" Uninit complete\n"); } } else { TRACESEND(" Uninit complete\n"); } } }
void MBFTPrivateSend::SendChannelInvitePDU(void) { MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_PERMANENT_ERROR;
DBG_SAVE_FILE_LINE LPPRIVATECHANNELINVITEPDU lpNewPDU = new PrivateChannelInvitePDU(m_PrivateMBFTControlChannel, m_PrivateMBFTDataChannel, FALSE); if(lpNewPDU) { if(lpNewPDU->Encode()) { for (ULONG Index = m_LastUserCount;Index < m_iUserCount;Index++) { if(m_lpParentEngine->SendDataRequest(m_lpUserArray[Index], APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { TRACESEND(" Sent Channel invite PDU, Control Channel [%u], Data Channel [%u] to [%u]\n",m_PrivateMBFTControlChannel,m_PrivateMBFTDataChannel,m_lpUserArray[Index]); m_LastUserCount++; } else { m_State = EnumWaitSendChannelInvitePDU; break; } }
if(Index >= m_iUserCount) { AdmitControlChannel(); } } else { iErrorCode = iMBFT_ASN1_ENCODING_ERROR; }
delete lpNewPDU; } else { iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; }
if(iErrorCode != iMBFT_OK) { ReportError(iErrorType,iErrorCode,TRUE); UnInitialize(); } } BOOL MBFTPrivateSend::OnReceivedFileAbortPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEABORTPDU lpFileAbortPDU, BOOL IsUniformSendData ) { MBFTFILEHANDLE hFile = lpFileAbortPDU->GetFileHandle();
if (hFile && hFile == m_CurrentFileHandle) { if (m_bUnInitializing) { OnControlNotification(hFile, FileTransferControlMsg::EnumConductorAbortFile, NULL, NULL); } return TRUE; // handled
}
return FALSE; // not handled
}
void MBFTPrivateSend::DoStateMachine(void) { if(m_State == EnumFileSendPending) { ConveneControlChannel(); } else if(m_State == EnumWaitRequestControlConvene) { ConveneControlChannel(); } else if(m_State == EnumWaitRequestJoinControl) { JoinControlChannel(); } else if(m_State == EnumWaitRequestDataConvene) { ConveneDataChannel(); } else if(m_State == EnumWaitSendChannelInvitePDU) { SendChannelInvitePDU(); } else if(m_State == EnumSendNonStandardPDU) { TRACESEND(" Not Sending a NonStandardPDU"); m_State = EnumSendFileOfferPDU; SendFileOfferPDU(); } else if(m_State == EnumSendFileOfferPDU) { SendFileOfferPDU(); } else if(m_State == EnumSendFileStartPDU) { SendFileStartPDU(); } else if(m_State == EnumSendFileDataPDU) { SendFileDataPDU(); } else if(m_State == EnumTerminateCurrentSend) { TerminateCurrentSend(); } else if(m_State == EnumWaitForTermination) { UnInitialize(); } else if(m_State == EnumWaitChannelResponsePDU) { if(GetTickCount() >= m_TimeOutValue) { // LOGERROR(iMBFT_TIMEOUT_ERROR,0,0);
ReportError(MBFT_PERMANENT_ERROR,iMBFT_TIMEOUT_ERROR,TRUE); UnInitialize(); } }
return; } BOOL MBFTPrivateSend::OnReceivedPrivateChannelResponsePDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPPRIVATECHANNELRESPONSEPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE;
if(m_State == EnumWaitChannelResponsePDU) { if(wChannelId == m_MBFTChannelID && lpNewPDU->GetControlChannel() == m_PrivateMBFTControlChannel) { bReturn = TRUE;
TRACESEND(" Received Channel response PDU from [%u]\n",SenderID);
for (ULONG Index = 0; Index < m_iUserCount; Index++) { if(m_lpUserArray[Index] == SenderID) { m_ResponseCount++; } }
if(!lpNewPDU->GetWasChannelJoined()) { ReportError(MBFT_INFORMATIVE_ERROR, iMBFT_RECEIVER_ABORTED, FALSE, SenderID, _iMBFT_PROSHARE_ALL_FILES);
RemoveUserFromList(SenderID); }
if(m_iUserCount) { if(m_ResponseCount >= m_iUserCount) { m_State = (! m_bProshareTransfer) ? EnumSendFileOfferPDU : EnumSendNonStandardPDU; } } } }
return(bReturn); }
void MBFTPrivateSend::SendFileOfferPDU(void) { MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_TRANSIENT_ERROR;
m_AcceptCount = 0; m_RejectCount = 0; m_ResponseCount = 0; m_AcknowledgeCount = 0; m_lTotalBytesRead = 0; m_SentFileStartPDU = FALSE; m_AbortedCount = 0; m_bSentFileOfferPDU = FALSE; m_AcceptedIndex = 0;
::ZeroMemory(m_lpAcceptedUsersArray, sizeof(UserID) * m_iUserCount);
if (m_lpFile->Open(m_pszCurrentFilePath, CMBFTFile::OpenReadOnly | CMBFTFile::OpenBinary)) { m_CurrentFileSize = m_lpFile->GetFileSize(); m_CurrentDateTime = m_lpFile->GetFileDateTime();
DBG_SAVE_FILE_LINE LPFILEOFFERPDU lpNewPDU = new FileOfferPDU(GetFileNameFromPath(m_pszCurrentFilePath), LOWORD(m_CurrentFileHandle), m_CurrentFileSize, m_CurrentDateTime, m_PrivateMBFTDataChannel,TRUE, m_lpParentEngine->GetRosterInstance(), 0, NULL, 0, 0); if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_PrivateMBFTControlChannel, APPLET_HIGH_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { TRACESEND(" Transmitted File Offer PDU for [%u] on [%u]\n",LOWORD(m_CurrentFileHandle),m_PrivateMBFTControlChannel);
//Now that we have sent a FileOfferPDU, we can't disband the channel
//without notice....
m_bOKToDisbandChannel = FALSE;
m_bSentFileOfferPDU = TRUE; m_State = EnumWaitFileAcceptPDU; } } else { iErrorCode = iMBFT_ASN1_ENCODING_ERROR; }
delete lpNewPDU; } else { iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } } else { iErrorCode = (MBFT_ERROR_CODE)m_lpFile->GetLastErrorCode();
//iMBFT_FILE_IO_ERROR;
}
if(iErrorCode != iMBFT_OK) { ReportError(iErrorType,iErrorCode,TRUE);
if(m_bSentFileOfferPDU) { //If a FileOffer has been sent out, we need to send a FileStartPDU with
//EOF = TRUE...
TerminateCurrentSend(); } else { ReportError(MBFT_INFORMATIVE_ERROR,iMBFT_SENDER_ABORTED,TRUE, m_MBFTChannelID,m_CurrentFileHandle);
SendNextFile(); } } }
BOOL MBFTPrivateSend::OnReceivedFileAcceptPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEACCEPTPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE;
if(m_State == EnumWaitFileAcceptPDU) { if(wChannelId == m_MBFTChannelID) { if(lpNewPDU->GetFileHandle() == m_CurrentFileHandle) { TRACESEND(" Received file accept PDU from [%u] for [%u]\n",SenderID,lpNewPDU->GetFileHandle());
bReturn = TRUE;
for (ULONG Index = 0; Index < m_iUserCount; Index++) { if(m_lpUserArray[Index] == SenderID) { if(m_AcceptedIndex < m_iUserCount) { m_lpAcceptedUsersArray[m_AcceptedIndex++] = SenderID; }
m_AcceptCount++; m_ResponseCount++; } }
if(m_ResponseCount >= m_iUserCount) { m_State = EnumSendFileStartPDU; } } } }
return(bReturn); } BOOL MBFTPrivateSend::OnReceivedFileRejectPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEREJECTPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE;
if(m_State == EnumWaitFileAcceptPDU) { if(wChannelId == m_MBFTChannelID) { MBFTFILEHANDLE iFileHandle = lpNewPDU->GetFileHandle();
if((iFileHandle == m_CurrentFileHandle) || ((iFileHandle == LOWORD(_iMBFT_PROSHARE_ALL_FILES)) && m_bProshareTransfer)) { TRACESEND(" Received file reject PDU from [%u] for [%u]\n",SenderID,lpNewPDU->GetFileHandle());
for(ULONG Index = 0;Index < m_iUserCount;Index++) { if(m_lpUserArray[Index] == SenderID) { bReturn = TRUE; } }
if(bReturn) { if(iFileHandle == m_CurrentFileHandle) { m_RejectCount++; m_ResponseCount++; } else if((iFileHandle == LOWORD(_iMBFT_PROSHARE_ALL_FILES)) && m_bProshareTransfer) {
RemoveUserFromList(SenderID); }
if(m_iUserCount) { if(m_ResponseCount >= m_iUserCount) { if(m_ResponseCount != m_RejectCount) { m_State = EnumSendFileStartPDU; } else { m_lpFile->Close(); SendNextFile(); } } } } //if bReturn
} } //wChannelId == m_MBFTChannelID
} //m_State == EnumWaitFileAcceptPDU
return(bReturn); }
BOOL MBFTPrivateSend::OnReceivedFileErrorPDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEERRORPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE; MBFTFILEHANDLE FileHandle = lpNewPDU->GetFileHandle();
if ((m_CurrentFileHandle == FileHandle) || (m_bProshareTransfer && (LOWORD(FileHandle) == LOWORD(_iMBFT_PROSHARE_ALL_FILES)))) { TRACERECEIVE(" FileErrorPDU from [%u] for [%u], ErrorCode: [%u]\n",SenderID,lpNewPDU->GetFileHandle(),lpNewPDU->GetErrorCode());
if(m_bProshareTransfer) { if(m_State != EnumWaitForTermination) { if(lpNewPDU->GetErrorCode() == iMBFT_RECEIVER_ABORTED && lpNewPDU->GetFileHandle() == LOWORD(_iMBFT_PROSHARE_ALL_FILES)) { m_AbortedCount++;
RemoveUserFromList(SenderID);
//If the state is EnumWaitFileAcceptPDU, we don't
//have an exact count of the number of recipients who accepted
//the file. Therefore, we cannot make a decision on whether or not
//to abort the file based on AcceptCount and AbortedCount....
if(m_State != EnumWaitFileAcceptPDU) { if(m_iUserCount) { if(m_AbortedCount >= m_AcceptCount) { m_lpFile->Close(); SendNextFile(); } } else { m_lpFile->Close(); } } else if(m_iUserCount) { //In this case, the FileErrorPDU acts as a FileRejectPDU...
TRACERECEIVE(" Treating FileErrorPDU for [%u] as FileRejectPDU\n",lpNewPDU->GetFileHandle());
//m_RejectCount++;
//m_ResponseCount++;
//In this case, response count has to be greater
//because a user was just deleted!!!
if(m_ResponseCount >= m_iUserCount) { if(m_ResponseCount != m_RejectCount) { m_State = EnumSendFileStartPDU; } else { SendNextFile(); } } } } else if (FileHandle == m_CurrentFileHandle) { m_AbortedCount++;
//If the state is EnumWaitFileAcceptPDU, we don't
//have an exact count of the number of recipients who accepted
//the file. Therefore, we cannot make a decision on whether or not
//to abort the file based on AcceptCount and AbortedCount....
if(m_State != EnumWaitFileAcceptPDU) { if(m_AbortedCount >= m_AcceptCount) { m_lpFile->Close(); SendNextFile(); } } else { //In this case, the FileErrorPDU acts as a FileRejectPDU...
TRACERECEIVE(" Treating FileErrorPDU for [%u] as FileRejectPDU\n",lpNewPDU->GetFileHandle());
m_RejectCount++; m_ResponseCount++;
if(m_ResponseCount >= m_iUserCount) { if(m_ResponseCount != m_RejectCount) { m_State = EnumSendFileStartPDU; } else { SendNextFile(); } } } } } //EnumWaitForTermination
} //IsProshare
}
return(bReturn); }
BOOL MBFTPrivateSend::OnReceivedNonStandardPDU ( T120ChannelID wChannelID, T120Priority iPriority, T120UserID SenderID, LPNONSTANDARDPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE;
if(m_State != EnumWaitForTermination) { if(wChannelID == m_PrivateMBFTControlChannel) { if (! ::lstrcmpA(lpNewPDU->GetKey(), PROSHARE_FILE_END_STRING)) { TRACESEND(" Received Non Standard PDU (File End Acknowledge) from [%u]\n",SenderID); FileEndAcknowledgeStruct * lpStruct = (FileEndAcknowledgeStruct *)lpNewPDU->GetDataBuffer();
DBG_SAVE_FILE_LINE LPFILEENDACKNOWLEDGEPDU lpNewPDU = new FileEndAcknowledgePDU(lpStruct->m_FileHandle); if (NULL != lpNewPDU) { bReturn = OnReceivedFileEndAcknowledgePDU(wChannelID, iPriority, SenderID, lpNewPDU, IsUniformSendData); delete lpNewPDU; } } else if (! ::lstrcmpA(lpNewPDU->GetKey(), PROSHARE_CHANNEL_LEAVE_STRING)) { TRACESEND(" Received Non Standard PDU (Channel Leave) from [%u]\n",SenderID);
ChannelLeaveStruct * lpStruct = (ChannelLeaveStruct *)lpNewPDU->GetDataBuffer();
DBG_SAVE_FILE_LINE LPCHANNELLEAVEPDU lpNewPDU = new ChannelLeavePDU(lpStruct->m_ChannelID,lpStruct->m_ErrorCode); if (NULL != lpNewPDU) { bReturn = OnReceivedChannelLeavePDU(wChannelID, iPriority, SenderID, lpNewPDU, IsUniformSendData); delete lpNewPDU; } } else { TRACE("*** Unknown Non Standard PDU received on [%u] *** \n",wChannelID); } } }
return(bReturn); }
BOOL MBFTPrivateSend::OnReceivedFileEndAcknowledgePDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPFILEENDACKNOWLEDGEPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE;
if(m_State == EnumWaitFileEndAcknowledgePDU) { if(wChannelId == m_PrivateMBFTControlChannel) { if(lpNewPDU->GetFileHandle() == m_CurrentFileHandle) { TRACESEND(" Received file end acknowledge PDU from [%u] for [%u]\n",SenderID,lpNewPDU->GetFileHandle());
bReturn = TRUE;
for (ULONG Index = 0; Index < m_AcceptedIndex; Index++) { if(m_lpAcceptedUsersArray[Index] == SenderID) { m_AcknowledgeCount++; } }
if(m_AcknowledgeCount >= m_AcceptCount) { SendNextFile(); } } } }
return(bReturn); } BOOL MBFTPrivateSend::OnReceivedChannelLeavePDU ( T120ChannelID wChannelId, T120Priority iPriority, T120UserID SenderID, LPCHANNELLEAVEPDU lpNewPDU, BOOL IsUniformSendData ) { BOOL bReturn = FALSE;
if(m_State == EnumSendFileStartPDU || m_State == EnumSendFileDataPDU || m_State == EnumWaitFileEndAcknowledgePDU) { if(lpNewPDU->GetChannelID() == m_PrivateMBFTDataChannel) { bReturn = TRUE;
TRACESEND(" Received Channel Leave PDU from [%u] for [%u], CurrentFile [%u]\n", SenderID,lpNewPDU->GetChannelID(),m_CurrentFileHandle);
for (ULONG Index = 0; Index < m_AcceptedIndex; Index++) { if(m_lpAcceptedUsersArray[Index] == SenderID) { m_AcknowledgeCount++; } }
if(m_State == EnumWaitFileEndAcknowledgePDU) { if(m_AcknowledgeCount >= m_AcceptCount) { SendNextFile(); } } } }
return(bReturn); }
void MBFTPrivateSend::SendFileStartPDU(void) { if(!m_bAbortAllFiles) { MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_TRANSIENT_ERROR;
LONG lCurrentPosition = m_lpFile->Seek(0L,CMBFTFile::SeekMode::SeekFromCurrent); FILE_HEADER_INFO fileHeaderInfo; fileHeaderInfo.fileName = (LPSTR)GetFileNameFromPath(m_pszCurrentFilePath); fileHeaderInfo.fileSize = m_CurrentFileSize; fileHeaderInfo.pduType = T127_FILE_START; GetFileHeaderSize(&fileHeaderInfo);
int iSizeofFileHeader = fileHeaderInfo.pduSize + sizeof(T127_FILE_START_DATA_BLOCK_HEADER); int iBytesRead = m_lpFile->Read(m_lpDataBuffer + iSizeofFileHeader ,m_MaxDataLength); m_bSendingFile = TRUE;
if(iBytesRead != -1) { BOOL bIsEOF = (m_lTotalBytesRead + iBytesRead) >= m_CurrentFileSize; LPFILESTARTPDU lpNewPDU = NULL;
if(!iBytesRead) { DBG_SAVE_FILE_LINE lpNewPDU = new FileStartPDU(m_lpDataBuffer, fileHeaderInfo.fileName, // GetFileNameFromPath(m_pszCurrentFilePath),
LOWORD(m_CurrentFileHandle), m_CurrentFileSize, m_CurrentDateTime, m_lpDataBuffer, 0, bIsEOF); } else { if(!m_bCompressFiles) { DBG_SAVE_FILE_LINE lpNewPDU = new FileStartPDU(m_lpDataBuffer, fileHeaderInfo.fileName, // GetFileNameFromPath(m_pszCurrentFilePath),
LOWORD(m_CurrentFileHandle), m_CurrentFileSize, m_CurrentDateTime, m_lpDataBuffer, iBytesRead, bIsEOF); } else { iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } }
if(iErrorCode == iMBFT_OK) { if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_PrivateMBFTDataChannel, APPLET_LOW_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { TRACESEND(" Sent file start PDU for [%ld] on [%u], EOF = [%d]\n", m_CurrentFileHandle, m_PrivateMBFTDataChannel, bIsEOF);
m_lTotalBytesRead += iBytesRead; m_SentFileStartPDU = TRUE;
SendNotificationMessage(iMBFT_FILE_SEND_BEGIN);
if(bIsEOF) { m_lpFile->Close(); if(!m_bEOFAcknowledge) { SendNextFile(); } else { TRACESEND(" Waiting for End of File ack PDU\n"); m_State = EnumWaitFileEndAcknowledgePDU; } } else { m_State = EnumSendFileDataPDU; } } else { m_lpFile->Seek(lCurrentPosition,CMBFTFile::SeekMode::SeekFromBegin); } } else { iErrorCode = iMBFT_ASN1_ENCODING_ERROR; } } //if(lpNewPDU)
else { iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; } } //if iErrorCode == iMBFT_OK
if(lpNewPDU) { lpNewPDU->NULLDataBuffer(); delete lpNewPDU; } } //If bytes read...
else { iErrorCode = (MBFT_ERROR_CODE)m_lpFile->GetLastErrorCode();
//iMBFT_FILE_IO_ERROR;
}
if(iErrorCode != iMBFT_OK) { ReportError(iErrorType,iErrorCode,TRUE); ReportSenderError(iErrorType,iErrorCode); TerminateCurrentSend(); } } else { TerminateCurrentSend(); } } void MBFTPrivateSend::SendNotificationMessage ( int iProgress, T120UserID iUserID, MBFTFILEHANDLE hFileHandle ) { T120UserID id = iUserID ? iUserID : m_MBFTChannelID;
DBG_SAVE_FILE_LINE m_lpParentEngine->SafePostNotifyMessage( new FileTransmitMsg(m_EventHandle, hFileHandle ? hFileHandle : m_CurrentFileHandle, m_CurrentFileSize, m_lTotalBytesRead, iProgress, id)); }
void MBFTPrivateSend::TerminateCurrentSend(void) { m_State = EnumTerminateCurrentSend;
ReportError(MBFT_INFORMATIVE_ERROR,iMBFT_SENDER_ABORTED,TRUE, m_MBFTChannelID,m_CurrentFileHandle);
//We don't care about compression in this case because the buffer is NULL....
DBG_SAVE_FILE_LINE LPFILEDATAPDU lpNewPDU = new FileDataPDU(m_lpDataBuffer,LOWORD(m_CurrentFileHandle),m_lpDataBuffer,0, FALSE, TRUE); if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_PrivateMBFTDataChannel, APPLET_LOW_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { m_lpFile->Close(); SendNextFile(); } } lpNewPDU->NULLDataBuffer(); delete lpNewPDU; } }
void MBFTPrivateSend::SendFileDataPDU(void) { LONG lCurrentPosition = -1; LPFILEDATAPDU lpNewPDU = NULL; int iBytesRead,Index; BOOL bIsEOF = FALSE,bTerminate = FALSE; MBFT_ERROR_CODE iErrorCode = iMBFT_OK; MBFT_ERROR_TYPES iErrorType = MBFT_TRANSIENT_ERROR;
if(!m_bAbortFileSend) { for(Index = 0;(Index < _MAX_SEND_PACKETS) && !bTerminate;Index++) { lCurrentPosition = m_lpFile->Seek(0L,CMBFTFile::SeekMode::SeekFromCurrent); iBytesRead = m_lpFile->Read(m_lpDataBuffer + sizeof(T127_FILE_DATA_HEADER),m_MaxDataLength); if(iBytesRead != -1) { BOOL bDataSent = FALSE; bIsEOF = m_lpFile->GetIsEOF();
if(!m_bCompressFiles) { DBG_SAVE_FILE_LINE lpNewPDU = new FileDataPDU(m_lpDataBuffer, LOWORD(m_CurrentFileHandle), m_lpDataBuffer,iBytesRead,bIsEOF, FALSE); } else { // MSFT error - no compression
}
if(lpNewPDU) { if(lpNewPDU->Encode()) { if(m_lpParentEngine->SendDataRequest(m_PrivateMBFTDataChannel, APPLET_LOW_PRIORITY, (LPBYTE)lpNewPDU->GetBuffer(), lpNewPDU->GetBufferLength())) { TRACESEND(" Sent file data PDU on [%u], EOF = [%d], BufferSize = [%d]\n",m_PrivateMBFTDataChannel,bIsEOF,lpNewPDU->GetBufferLength());
//m_lTotalBytesRead += iBytesRead;
m_lTotalBytesRead = m_lpFile->Seek(0L,CMBFTFile::SeekMode::SeekFromCurrent);
bDataSent = TRUE;
SendNotificationMessage(iMBFT_FILE_SEND_PROGRESS);
if(bIsEOF) { m_lpFile->Close();
if(!m_bEOFAcknowledge) { SendNextFile(); } else { TRACESEND(" Waiting for End of File ack PDU\n"); m_State = EnumWaitFileEndAcknowledgePDU; }
bTerminate = TRUE; } }
if(!bDataSent) { m_lpFile->Seek(lCurrentPosition,CMBFTFile::SeekMode::SeekFromBegin); bTerminate = TRUE; } } else { iErrorCode = iMBFT_ASN1_ENCODING_ERROR; break; } lpNewPDU->NULLDataBuffer(); delete lpNewPDU; } else { iErrorCode = iMBFT_MEMORY_ALLOCATION_ERROR; break; } } else { iErrorCode = (MBFT_ERROR_CODE)m_lpFile->GetLastErrorCode();
//iMBFT_FILE_IO_ERROR;
break; } } //for loop
} else { TerminateCurrentSend(); }
if(iErrorCode != iMBFT_OK) { ReportError(iErrorType,iErrorCode,TRUE); ReportSenderError(iErrorType,iErrorCode); TerminateCurrentSend(); } }
void MBFTPrivateSend::RemoveFileFromList ( MBFTFILEHANDLE hFile ) { if (hFile == m_CurrentFileHandle) { ReportError(MBFT_PERMANENT_ERROR,iMBFT_NO_MORE_FILES,TRUE); TerminateSendSession(); } }
BOOL MBFTPrivateSend::RemoveUserFromAcceptedList ( T120UserID iUserID ) { BOOL bUserRemoved = FALSE;
for (ULONG Index = 1; Index <= m_AcceptedIndex; Index++) { if(m_lpAcceptedUsersArray[Index - 1] == iUserID) { bUserRemoved = TRUE;
if(Index != m_AcceptedIndex) { CopyMemory(&m_lpAcceptedUsersArray[Index - 1],&m_lpAcceptedUsersArray[Index], (m_AcceptedIndex - Index) * sizeof(UserID)); }
m_AcceptedIndex--; } }
return(bUserRemoved); }
BOOL MBFTPrivateSend::RemoveUserFromList ( T120UserID iUserID ) { BOOL bUserRemoved = FALSE;
for (ULONG Index = 1; Index <= m_iUserCount; Index++) { if(m_lpUserArray[Index - 1] == iUserID) { bUserRemoved = TRUE;
if(Index != m_iUserCount) { CopyMemory(&m_lpUserArray[Index - 1],&m_lpUserArray[Index], (m_iUserCount - Index) * sizeof(UserID)); }
m_iUserCount--; } }
if(bUserRemoved) { if(!m_iUserCount) { ReportError(MBFT_PERMANENT_ERROR,iMBFT_NO_MORE_RECIPIENTS,TRUE);
if(m_State == EnumSendFileDataPDU || m_State == EnumSendFileOfferPDU || m_State == EnumWaitFileAcceptPDU) { if(m_lpFile) { m_lpFile->Close(); }
if(m_State == EnumSendFileDataPDU) { SendNotificationMessage(iMBFT_FILE_SEND_END); } }
TerminateSendSession(); } }
return(bUserRemoved); }
void MBFTPrivateSend::OnControlNotification ( MBFTFILEHANDLE hFile, FileTransferControlMsg::FileTransferControl iControlCommand, LPCSTR lpszDirectory, LPCSTR lpszFileName ) { if(iControlCommand == FileTransferControlMsg::EnumAbortFile || iControlCommand == FileTransferControlMsg::EnumConductorAbortFile) { if(m_bOKToDisbandChannel) { if(hFile == _iMBFT_PROSHARE_ALL_FILES /*&& m_bProshareTransfer*/) { //Fix to ensure a iMBFT_SENDER_ABORTED notification if sender aborts way too early...
ReportError(MBFT_INFORMATIVE_ERROR, (iControlCommand == FileTransferControlMsg::EnumAbortFile) ? iMBFT_SENDER_ABORTED : iMBFT_CONDUCTOR_ABORTED, TRUE, m_MBFTChannelID, _iMBFT_PROSHARE_ALL_FILES);
UnInitialize(); } else { RemoveFileFromList(hFile); } } else if(!m_bUnInitializing) { if(hFile == _iMBFT_PROSHARE_ALL_FILES) { AbortAllFiles(); } else if(hFile == m_CurrentFileHandle) { AbortCurrentFile(); } } } }
void MBFTPrivateSend::AbortAllFiles(void) { AbortCurrentFile(); m_bAbortAllFiles = TRUE; }
void MBFTPrivateSend::AbortCurrentFile(void) { if(m_bSendingFile) { m_bAbortFileSend = TRUE; } } void MBFTPrivateSend::SendNextFile(void) { // Notify the ui if some receivers didn't accept the previous file
if(m_AbortedCount) { // All the receivers aborted the FT, this is the same as the sender canceling FT
ReportError(MBFT_PERMANENT_ERROR, m_AbortedCount >= m_AcceptCount ? iMBFT_SENDER_ABORTED : iMBFT_MULT_RECEIVER_ABORTED, TRUE); } if(m_RejectCount) { // If we just had one FT an it rejected we say that there was a problem sending the file
// If we had more receivers we will use the receiver aborted message
ReportError(MBFT_PERMANENT_ERROR, m_AcceptCount == 0 ? iMBFT_RECEIVER_REJECTED : iMBFT_MULT_RECEIVER_ABORTED, TRUE); }
// We are sending or the receiver Rejected before we start sending
if(m_bSendingFile || m_RejectCount) { SendNotificationMessage(iMBFT_FILE_SEND_END); }
m_bSendingFile = FALSE; m_bAbortFileSend = FALSE;
TerminateSendSession(); }
void MBFTPrivateSend::OnPeerDeletedNotification ( CPeerData *lpPeerData ) { if(m_State != EnumWaitForTermination) { if(RemoveUserFromList(lpPeerData->GetUserID())) { if(m_iUserCount) { if(m_State == EnumWaitFileAcceptPDU || m_State == EnumWaitChannelResponsePDU) { //m_RejectCount++;
//m_ResponseCount++;
if(m_ResponseCount >= m_iUserCount) { if(m_State == EnumWaitFileAcceptPDU) { if(m_ResponseCount != m_RejectCount) { m_State = EnumSendFileStartPDU; } else { SendNextFile(); } } else if(m_State == EnumWaitChannelResponsePDU) { if(!m_bProshareTransfer) { m_State = EnumSendFileOfferPDU; } else { m_State = EnumSendNonStandardPDU; } } } //m_ResponseCount >= m_iUserCount
} else if ((m_State == EnumWaitFileEndAcknowledgePDU) || (m_State == EnumSendFileDataPDU)) { if(RemoveUserFromAcceptedList(lpPeerData->GetUserID())) { m_AcknowledgeCount++; } if(m_AcknowledgeCount >= m_AcceptCount) { SendNextFile(); } } } //UserCount
} //RemoveUserFromList
} //EnumWaitForTermination
}
|