You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2036 lines
70 KiB
2036 lines
70 KiB
/* file: mbft.cpp */
|
|
|
|
#include "mbftpch.h"
|
|
#include <it120app.h>
|
|
#include <version.h>
|
|
|
|
#define __NO_EXTERNS__
|
|
#include "mbft.hpp"
|
|
#include "osshelp.hpp"
|
|
#include "messages.hpp"
|
|
#include "mbftrecv.hpp"
|
|
#include "mbftsend.hpp"
|
|
|
|
void CALLBACK T120Callback(T120AppletSessionMsg *);
|
|
|
|
// from mbftapi.cpp
|
|
BOOL g_fWaitingForBufferAvailable = FALSE;
|
|
|
|
|
|
#ifdef ENABLE_HEARTBEAT_TIMER
|
|
|
|
// WM_TIMER has the lowest priority among window messages
|
|
#define IDLE_TIMER_SPEED 5000
|
|
#define SESSION_TIMER_SPEED 5
|
|
|
|
void HeartBeatTimerProc(HWND hWnd, UINT uMsg, UINT_PTR nTimerID, DWORD dwTime)
|
|
{
|
|
if (NULL != g_pFileXferApplet)
|
|
{
|
|
MBFTEngine *pEngine = g_pFileXferApplet->FindEngineByTimerID(nTimerID);
|
|
if (NULL != pEngine)
|
|
{
|
|
::PostMessage(g_pFileXferApplet->GetHiddenWnd(), MBFTMSG_HEART_BEAT,
|
|
0, (LPARAM) pEngine);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
MBFTEngine::MBFTEngine
|
|
(
|
|
MBFTInterface *pMBFTIntf,
|
|
MBFT_MODE eMode,
|
|
T120SessionID nSessionID
|
|
)
|
|
:
|
|
CRefCount(MAKE_STAMP_ID('F','T','E','g')),
|
|
|
|
m_pAppletSession(NULL),
|
|
m_eLastSendDataError(T120_NO_ERROR),
|
|
|
|
m_pMBFTIntf(pMBFTIntf),
|
|
|
|
m_fConfAvailable(FALSE),
|
|
m_fJoinedConf(FALSE),
|
|
|
|
m_uidMyself(0), // user id
|
|
m_nidMyself(0), // node id
|
|
m_eidMyself(0), // entity id
|
|
|
|
m_eMBFTMode(eMode),
|
|
m_SessionID(nSessionID),
|
|
|
|
m_MBFTControlChannel(nSessionID),
|
|
m_MBFTDataChannel(0),
|
|
|
|
m_nRosterInstance(0),
|
|
|
|
m_nConfID(0),
|
|
|
|
m_MBFTMaxFileSize(_iMBFT_MAX_FILE_SIZE),
|
|
|
|
m_MBFTMaxDataPayload(_iMBFT_DEFAULT_MAX_FILEDATA_PDU_LENGTH),
|
|
m_MBFTMaxSendDataPayload(_iMBFT_DEFAULT_MAX_MCS_SIZE - _iMBFT_FILEDATA_PDU_SUBTRACT),
|
|
|
|
m_bV42CompressionSupported(FALSE),
|
|
m_v42bisP1(_iMBFT_V42_NO_OF_CODEWORDS),
|
|
m_v42bisP2(_iMBFT_V42_MAX_STRING_LENGTH),
|
|
|
|
// LONCHANC: NetMeeting's Node Controller does not exercise conductorship.
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
m_bInConductedMode(FALSE),
|
|
m_ConductorNodeID(0),
|
|
m_MBFTConductorID(0),
|
|
m_ConductedModePermission(0),
|
|
m_bWaitingForPermission(FALSE),
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
|
|
m_pWindow(NULL),
|
|
m_State(IdleNotInitialized)
|
|
{
|
|
g_fWaitingForBufferAvailable = FALSE;
|
|
|
|
switch (m_eMBFTMode)
|
|
{
|
|
case MBFT_STATIC_MODE:
|
|
ASSERT(m_MBFTControlChannel == _MBFT_CONTROL_CHANNEL);
|
|
m_MBFTDataChannel = _MBFT_DATA_CHANNEL;
|
|
break;
|
|
|
|
#ifdef USE_MULTICAST_SESSION
|
|
case MBFT_MULTICAST_MODE:
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
ERROR_OUT(("MBFTEngine::MBFTEngine: invalid session type=%u", m_eMBFTMode));
|
|
break;
|
|
}
|
|
|
|
// clear join session structures
|
|
::ZeroMemory(&m_aStaticChannels, sizeof(m_aStaticChannels));
|
|
#ifdef USE_MULTICAST_SESSION
|
|
::ZeroMemory(&m_aJoinResourceReqs, sizeof(m_aJoinResourceReqs));
|
|
#endif
|
|
::ZeroMemory(&m_JoinSessionReq, sizeof(m_JoinSessionReq));
|
|
|
|
ASSERT(NULL != g_pFileXferApplet);
|
|
g_pFileXferApplet->RegisterEngine(this);
|
|
|
|
m_pWindow = g_pFileXferApplet->GetUnattendedWindow();
|
|
if (NULL != m_pWindow)
|
|
{
|
|
m_pWindow->RegisterEngine(this);
|
|
}
|
|
|
|
#ifdef ENABLE_HEARTBEAT_TIMER
|
|
m_nTimerID = ::SetTimer(NULL, 0, IDLE_TIMER_SPEED, HeartBeatTimerProc);
|
|
#endif
|
|
}
|
|
|
|
MBFTEngine::~MBFTEngine(void)
|
|
{
|
|
#ifdef ENABLE_HEARTBEAT_TIMER
|
|
// kill the timer now
|
|
::KillTimer(NULL, m_nTimerID);
|
|
#endif
|
|
|
|
// the interface object is already gone
|
|
m_pMBFTIntf = NULL;
|
|
|
|
MBFTSession *pSession;
|
|
while (NULL != (pSession = m_SessionList.Get()))
|
|
{
|
|
pSession->UnInitialize(FALSE);
|
|
delete pSession; // LONCHANC: not sure about this delete
|
|
}
|
|
|
|
if (NULL != m_pAppletSession)
|
|
{
|
|
m_pAppletSession->ReleaseInterface();
|
|
}
|
|
|
|
ASSERT(! m_fJoinedConf);
|
|
|
|
m_PeerList.DeleteAll();
|
|
}
|
|
|
|
void MBFTEngine::SetInterfacePointer( MBFTInterface *pIntf )
|
|
{
|
|
CPeerData *pPeerData;
|
|
|
|
ASSERT (pIntf);
|
|
m_pMBFTIntf = pIntf;
|
|
m_PeerList.Reset();
|
|
while (NULL != (pPeerData = m_PeerList.Iterate()))
|
|
{
|
|
if (pPeerData->GetNodeID() != m_nidMyself)
|
|
{
|
|
AddPeerNotification(pPeerData->GetNodeID(),
|
|
pPeerData->GetUserID(),
|
|
pPeerData->GetIsLocalNode(),
|
|
pPeerData->GetIsProshareNode(), TRUE,
|
|
pPeerData->GetAppKey(),
|
|
m_SessionID);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL MBFTEngine::Has2xNodeInConf(void)
|
|
{
|
|
CPeerData *pPeerData;
|
|
m_PeerList.Reset();
|
|
while (NULL != (pPeerData = m_PeerList.Iterate()))
|
|
{
|
|
// if (pPeerData->GetVersion() < HIWORD(VER_PRODUCTVERSION_DW))
|
|
if (pPeerData->GetVersion() < 0x0404)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL MBFTEngine::HasSDK(void)
|
|
{
|
|
return (m_pMBFTIntf ? TRUE : FALSE);
|
|
}
|
|
|
|
|
|
HRESULT MBFTEngine::SafePostMessage
|
|
(
|
|
MBFTMsg *pMsg
|
|
)
|
|
{
|
|
if (NULL != pMsg)
|
|
{
|
|
AddRef();
|
|
if( 0 == ::PostMessage(g_pFileXferApplet->GetHiddenWnd(), MBFTMSG_BASIC, (WPARAM) pMsg, (LPARAM) this) )
|
|
{
|
|
Release();
|
|
delete pMsg;
|
|
pMsg = NULL;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
ERROR_OUT(("MBFTEngine::SafePostMessage: null msg ptr"));
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
|
|
void MBFTEngine::OnPermitToEnrollIndication
|
|
(
|
|
GCCAppPermissionToEnrollInd *pInd
|
|
)
|
|
{
|
|
T120Error rc;
|
|
|
|
TRACEGCC( " Permission to enroll in conference [%d] is %sgranted.\n",
|
|
pInd->nConfID, pInd->fPermissionGranted?"":"not " );
|
|
|
|
m_fConfAvailable = pInd->fPermissionGranted;
|
|
|
|
if (pInd->fPermissionGranted)
|
|
{
|
|
m_nConfID = pInd->nConfID;
|
|
|
|
// build the common part of the join session request for the base session
|
|
ASSERT(m_SessionID == m_MBFTControlChannel);
|
|
::ZeroMemory(&m_JoinSessionReq, sizeof(m_JoinSessionReq));
|
|
m_JoinSessionReq.dwAttachmentFlags = ATTACHMENT_DISCONNECT_IN_DATA_LOSS;
|
|
m_JoinSessionReq.fConductingCapable = FALSE;
|
|
m_JoinSessionReq.nStartupChannelType = MCS_STATIC_CHANNEL;
|
|
m_JoinSessionReq.cNonCollapsedCaps = sizeof(g_aAppletNonCollCaps) / sizeof(g_aAppletNonCollCaps[0]);
|
|
m_JoinSessionReq.apNonCollapsedCaps = (GCCNonCollCap **) &g_aAppletNonCollCaps[0];
|
|
m_JoinSessionReq.cCollapsedCaps = sizeof(g_aAppletCaps) / sizeof(g_aAppletCaps[0]);
|
|
m_JoinSessionReq.apCollapsedCaps = (GCCAppCap **) &g_aAppletCaps[0];
|
|
|
|
// put in the session ID which is the control channel ID
|
|
m_JoinSessionReq.SessionKey = g_AppletSessionKey;
|
|
m_JoinSessionReq.SessionKey.session_id = m_SessionID;
|
|
m_aStaticChannels[0] = m_MBFTControlChannel;
|
|
|
|
// at least one static channel to join
|
|
m_JoinSessionReq.aStaticChannels = &m_aStaticChannels[0];
|
|
|
|
// build the complete join session request for the base session
|
|
switch (m_eMBFTMode)
|
|
{
|
|
case MBFT_STATIC_MODE:
|
|
ASSERT(m_MBFTControlChannel == _MBFT_CONTROL_CHANNEL);
|
|
ASSERT(m_MBFTDataChannel = _MBFT_DATA_CHANNEL);
|
|
m_aStaticChannels[1] = m_MBFTDataChannel;
|
|
m_JoinSessionReq.cStaticChannels = 2; // control and data channels
|
|
// m_JoinSessionReq.cResourceReqs = 0;
|
|
break;
|
|
|
|
#ifdef USE_MULTICAST_SESSION
|
|
case MBFT_MULTICAST_MODE:
|
|
m_JoinSessionReq.cStaticChannels = 1; // control channel only
|
|
::ZeroMemory(&m_aJoinResourceReqs, sizeof(m_aJoinResourceReqs));
|
|
m_aJoinResourceReqs[0].eCommand = APPLET_RETRIEVE_N_JOIN_CHANNEL;
|
|
m_aJoinResourceReqs[0].RegKey.resource_id.length = sizeof(DATA_CHANNEL_RESOURCE_ID) - 1;
|
|
m_aJoinResourceReqs[0].RegKey.resource_id.value = DATA_CHANNEL_RESOURCE_ID;
|
|
m_aJoinResourceReqs[0].RegKey.session_key = m_JoinSessionReq.SessionKey;
|
|
m_JoinSessionReq.cResourceReqs = sizeof(m_aJoinResourceReqs) / sizeof(m_aJoinResourceReqs[0]);
|
|
m_JoinSessionReq.aResourceReqs = &m_aJoinResourceReqs[0];
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
ERROR_OUT(("MBFTEngine::OnPermitToEnrollIndication: invalid session type=%u", m_eMBFTMode));
|
|
break;
|
|
}
|
|
|
|
// now, create the applet session
|
|
rc = g_pFileXferApplet->CreateAppletSession(&m_pAppletSession, m_nConfID);
|
|
if (T120_NO_ERROR == rc)
|
|
{
|
|
ASSERT(NULL != m_pAppletSession);
|
|
m_pAppletSession->Advise(T120Callback, // callback function
|
|
g_pFileXferApplet, // applet context
|
|
this); // session context
|
|
|
|
rc = m_pAppletSession->Join(&m_JoinSessionReq);
|
|
}
|
|
|
|
if (T120_NO_ERROR != rc)
|
|
{
|
|
WARNING_OUT(("MBFTEngine::OnPermitToEnrollIndication: CreateAppletSession failed, rc=%u", rc));
|
|
DBG_SAVE_FILE_LINE
|
|
SafePostNotifyMessage(new InitUnInitNotifyMsg(EnumInitFailed));
|
|
}
|
|
} // in conference
|
|
else
|
|
// leaving the conference here
|
|
{
|
|
LPMBFTSESSION pSession;
|
|
m_SessionList.Reset();
|
|
while (NULL != (pSession = m_SessionList.Iterate()))
|
|
{
|
|
pSession->UnInitialize( TRUE );
|
|
}
|
|
|
|
//Time to say goodbye...
|
|
AddPeerNotification( m_nidMyself, m_uidMyself, TRUE, TRUE, FALSE, MY_APP_STR, m_SessionID );
|
|
|
|
//Clear the peer list...
|
|
m_PeerList.DeleteAll();
|
|
|
|
//Nuke all sessions except for the first one....
|
|
while (NULL != (pSession = m_SessionList.Get()))
|
|
{
|
|
delete pSession;
|
|
}
|
|
|
|
// leave the conference if not done so
|
|
if (NULL != m_pAppletSession)
|
|
{
|
|
m_pAppletSession->Unadvise();
|
|
|
|
// LONCHANC: I commented out the following line because we should not
|
|
// leave the conference until we are sure that we can release the interface.
|
|
// There are outstanding send-data-indication messages. If we leave now,
|
|
// we will not be able to free them...
|
|
// m_pAppletSession->Leave();
|
|
|
|
// let the core know we left the conference
|
|
DBG_SAVE_FILE_LINE
|
|
SafePostNotifyMessage(new InitUnInitNotifyMsg(EnumInvoluntaryUnInit));
|
|
}
|
|
|
|
// we are not in the conference anymore
|
|
m_fJoinedConf = FALSE;
|
|
|
|
// release this engine object in the next tick
|
|
::PostMessage(g_pFileXferApplet->GetHiddenWnd(), MBFTMSG_DELETE_ENGINE, 0, (LPARAM) this);
|
|
}
|
|
}
|
|
|
|
|
|
void MBFTEngine::OnJoinSessionConfirm
|
|
(
|
|
T120JoinSessionConfirm *pConfirm
|
|
)
|
|
{
|
|
if (T120_RESULT_SUCCESSFUL == pConfirm->eResult)
|
|
{
|
|
if (pConfirm->pIAppletSession == m_pAppletSession)
|
|
{
|
|
m_uidMyself = pConfirm->uidMyself;
|
|
m_eidMyself = pConfirm->eidMyself;
|
|
m_nidMyself = pConfirm->nidMyself;
|
|
ASSERT(m_SessionID == pConfirm->sidMyself);
|
|
|
|
#ifdef USE_MULTICAST_SESSION
|
|
if (MBFT_MULTICAST_MODE == m_eMBFTMode)
|
|
{
|
|
ASSERT(1 == pConfirm->cResourceReqs);
|
|
ASSERT(0 == m_MBFTDataChannel);
|
|
ASSERT(APPLET_RETRIEVE_N_JOIN_CHANNEL == pConfirm->aResourceResults[0].eCommand);
|
|
m_MBFTDataChannel = pConfirm->aResourceResults[0].nChannelID;
|
|
ASSERT(0 != m_MBFTDataChannel);
|
|
}
|
|
#endif
|
|
|
|
// we are now officially in the conference
|
|
m_fJoinedConf = TRUE;
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("MBFTEngine::OnJoinSessionConfirm: not my session confirm, pConfirm->pI=0x%x, m_pI=0x%x", pConfirm->pIAppletSession, m_pAppletSession));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING_OUT(("MBFTEngine::OnJoinSessionConfirm: failed, result=%u", pConfirm->eResult));
|
|
DBG_SAVE_FILE_LINE
|
|
SafePostNotifyMessage(new InitUnInitNotifyMsg(EnumInitFailed));
|
|
}
|
|
}
|
|
|
|
|
|
CPeerData::CPeerData
|
|
(
|
|
T120NodeID NodeID,
|
|
T120UserID MBFTUserID,
|
|
BOOL bIsLocalNode,
|
|
BOOL IsProshareNode,
|
|
BOOL bCanConduct,
|
|
BOOL bEOFAcknowledgment,
|
|
LPCSTR lpszAppKey,
|
|
DWORD dwVersion
|
|
)
|
|
:
|
|
m_NodeID(NodeID),
|
|
m_MBFTUserID(MBFTUserID),
|
|
m_bIsLocalNode(bIsLocalNode),
|
|
m_bIsProshareNode(IsProshareNode),
|
|
m_bCanConduct(bCanConduct),
|
|
m_bEOFAcknowledgment(bEOFAcknowledgment),
|
|
m_dwVersion(dwVersion)
|
|
{
|
|
if (lpszAppKey)
|
|
{
|
|
::lstrcpynA(m_szAppKey, lpszAppKey, sizeof(m_szAppKey));
|
|
}
|
|
else
|
|
{
|
|
m_szAppKey[0] = '\0';
|
|
}
|
|
}
|
|
|
|
|
|
void MBFTEngine::AddPeerNotification
|
|
(
|
|
T120NodeID NodeID,
|
|
T120UserID MBFTUserID,
|
|
BOOL IsLocalNode,
|
|
BOOL IsProshareNode,
|
|
BOOL bPeerAdded,
|
|
LPCSTR lpszAppKey,
|
|
T120SessionID SessionID
|
|
)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
SafePostNotifyMessage(
|
|
new PeerMsg(NodeID, MBFTUserID, IsLocalNode, IsProshareNode,
|
|
lpszAppKey, bPeerAdded, SessionID));
|
|
}
|
|
|
|
|
|
void MBFTEngine::AddAllPeers(void)
|
|
{
|
|
T120NodeID nNodeId;
|
|
CPeerData *pPeerData;
|
|
|
|
m_PeerList.Reset();
|
|
while (NULL != (pPeerData = m_PeerList.Iterate()))
|
|
{
|
|
nNodeId = pPeerData->GetNodeID();
|
|
if (nNodeId != m_nidMyself)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
SafePostNotifyMessage(new PeerMsg(nNodeId, pPeerData->GetUserID(),
|
|
FALSE, pPeerData->GetIsProshareNode(),
|
|
pPeerData->GetAppKey(), TRUE, m_SessionID));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// LONCHANC: NetMeeting's Node Controller does not exercise conductorship.
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
void MBFTEngine::OnConductAssignIndication(GCCConductorAssignInd *pInd)
|
|
{
|
|
m_ConductorNodeID = pInd->nidConductor;
|
|
m_MBFTConductorID = 0;
|
|
m_ConductedModePermission = 0;
|
|
m_bWaitingForPermission = FALSE;
|
|
|
|
if (m_nidMyself == m_ConductorNodeID)
|
|
{
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumFileTransfer;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumFileRequest;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumPriority;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumPrivateChannel;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumAbort;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumNonStandard;
|
|
}
|
|
else
|
|
{
|
|
CPeerData *lpPeer;
|
|
if (NULL != (lpPeer = m_PeerList.Find(m_ConductorNodeID)))
|
|
{
|
|
if (lpPeer->GetCanConduct())
|
|
{
|
|
//Now that we have found a conductor on the conducting node,
|
|
//our search is over....
|
|
m_MBFTConductorID = lpPeer->GetUserID();
|
|
}
|
|
}
|
|
|
|
//MBFT 8.11.1
|
|
//If there is a change in the conductor, and there is no MBFT conductor at the
|
|
//new conducting node, all transactions must cease....
|
|
//The m_bInConductedMode flag tells us if we were already in the conducted mode.
|
|
if( !m_MBFTConductorID && m_bInConductedMode )
|
|
{
|
|
//Abort all transactions....
|
|
AbortAllSends();
|
|
}
|
|
}
|
|
|
|
m_bInConductedMode = TRUE;
|
|
}
|
|
|
|
void MBFTEngine::OnConductReleaseIndication( GCCConferenceID ConfID )
|
|
{
|
|
m_bInConductedMode = FALSE;
|
|
m_ConductorNodeID = 0;
|
|
m_MBFTConductorID = 0;
|
|
m_ConductedModePermission = 0;
|
|
m_bWaitingForPermission = FALSE;
|
|
}
|
|
|
|
void MBFTEngine::OnConductGrantIndication(GCCConductorPermitGrantInd *pInd)
|
|
{
|
|
UINT Index;
|
|
|
|
for( Index = 0; Index < pInd->Granted.cNodes; Index++ )
|
|
{
|
|
if (pInd->Granted.aNodeIDs[Index] == m_nidMyself)
|
|
{
|
|
if( pInd->fThisNodeIsGranted )
|
|
{
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumFileTransfer;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumFileRequest;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumPriority;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumPrivateChannel;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumAbort;
|
|
m_ConductedModePermission |= PrivilegeAssignPDU::EnumNonStandard;
|
|
}
|
|
else
|
|
{
|
|
//TO DO:
|
|
//MBFT 8.11.1 and 8.12.1
|
|
//If the MBFT provider receives a GCCConductorPermissionGrantIndication
|
|
//with permission_flag = FALSE, all privileges are revoked and all
|
|
//transactions should be terminated....
|
|
m_ConductedModePermission = 0;
|
|
AbortAllSends();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MBFTEngine::AbortAllSends(void)
|
|
{
|
|
if( m_bInConductedMode )
|
|
{
|
|
MBFTSession *pSession;
|
|
m_SessionList.Reset();
|
|
while (NULL != (pSession = m_SessionList.Iterate()))
|
|
{
|
|
if (pSession->GetSessionType() == MBFT_PRIVATE_SEND_TYPE)
|
|
{
|
|
pSession->OnControlNotification(
|
|
_iMBFT_PROSHARE_ALL_FILES,
|
|
FileTransferControlMsg::EnumConductorAbortFile,
|
|
NULL,
|
|
NULL );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
|
|
|
|
void MBFTEngine::OnDetachUserIndication
|
|
(
|
|
T120UserID mcsUserID,
|
|
T120Reason eReason
|
|
)
|
|
{
|
|
TRACEMCS(" Detach User Indication [%u]\n",mcsUserID);
|
|
|
|
if (mcsUserID == m_uidMyself)
|
|
{
|
|
m_fJoinedConf = FALSE;
|
|
m_pAppletSession->Unadvise();
|
|
|
|
//Time to say goodbye...
|
|
AddPeerNotification(m_nidMyself, m_uidMyself, TRUE, TRUE, FALSE, MY_APP_STR, m_SessionID);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL MBFTEngine::ProcessMessage(MBFTMsg *pMsg)
|
|
{
|
|
BOOL bWasHandled = FALSE;
|
|
BOOL bBroadcastFileOfferHack = FALSE;
|
|
MBFTSession *pSession;
|
|
|
|
// lonchanc: it is possible that the channel admit indication comes in
|
|
// before the session is created. in this case, put the message back to the queue.
|
|
if (m_SessionList.IsEmpty())
|
|
{
|
|
if (EnumMCSChannelAdmitIndicationMsg == pMsg->GetMsgType())
|
|
{
|
|
return FALSE; // do not delete the message and put it back to the queue
|
|
}
|
|
}
|
|
|
|
m_SessionList.Reset();
|
|
while (!bWasHandled && NULL != (pSession = m_SessionList.Iterate()))
|
|
{
|
|
switch (pMsg->GetMsgType())
|
|
{
|
|
case EnumMCSChannelAdmitIndicationMsg:
|
|
if (pSession->IsReceiveSession())
|
|
{
|
|
MBFTPrivateReceive *pRecvSession = (MBFTPrivateReceive *) pSession;
|
|
MCSChannelAdmitIndicationMsg *p = (MCSChannelAdmitIndicationMsg *) pMsg;
|
|
//We have to make an exception in the case because we get this
|
|
//message before the PrivateChannelInvitePDU() !!!
|
|
bWasHandled = pRecvSession->OnMCSChannelAdmitIndication(p->m_wChannelId, p->m_ManagerID);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEMCS(" Channel Admit Indication [%u], Manager [%u]\n", p->m_wChannelId, p->m_ManagerID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumMCSChannelExpelIndicationMsg:
|
|
if (pSession->IsReceiveSession())
|
|
{
|
|
MBFTPrivateReceive *pRecvSession = (MBFTPrivateReceive *) pSession;
|
|
MCSChannelExpelIndicationMsg *p = (MCSChannelExpelIndicationMsg *) pMsg;
|
|
bWasHandled = pRecvSession->OnMCSChannelExpelIndication(p->m_wChannelId, p->m_iReason);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEMCS(" Channel Expel Indication [%u]\n", p->m_wChannelId);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumMCSChannelJoinConfirmMsg:
|
|
{
|
|
MCSChannelJoinConfirmMsg *p = (MCSChannelJoinConfirmMsg *) pMsg;
|
|
bWasHandled = pSession->OnMCSChannelJoinConfirm(p->m_wChannelId, p->m_bSuccess);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEMCS(" Channel Join Confirm [%u], Success = [%d]\n", p->m_wChannelId, p->m_bSuccess);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumMCSChannelConveneConfirmMsg:
|
|
if (pSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) pSession;
|
|
MCSChannelConveneConfirmMsg *p = (MCSChannelConveneConfirmMsg *) pMsg;
|
|
bWasHandled = pSendSession->OnMCSChannelConveneConfirm(p->m_wChannelId, p->m_bSuccess);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEMCS(" Channel Convene Confirm [%u], Success = [%d]\n", p->m_wChannelId, p->m_bSuccess);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumGenericMBFTPDUMsg:
|
|
{
|
|
MBFTPDUMsg *p = (MBFTPDUMsg *) pMsg;
|
|
bWasHandled = DispatchPDUMessage(pSession, p);
|
|
|
|
//Background on this hack:
|
|
//In the broadcast mode, we may get a FileOfferPDU followed by a FileStart
|
|
//PDU and may therefore not give the client application sufficient time
|
|
//to process the File Offer. Therefore, we make sure that we stop processing
|
|
//other messages if we get a broadcast FileOffer...
|
|
if(bWasHandled)
|
|
{
|
|
if (p->m_PDUType == EnumFileOfferPDU)
|
|
{
|
|
LPFILEOFFERPDU lpNewFileOfferPDU = (LPFILEOFFERPDU) p->m_lpNewPDU;
|
|
if(lpNewFileOfferPDU->GetAcknowledge() == 0)
|
|
{
|
|
bBroadcastFileOfferHack = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumPeerDeletedMsg:
|
|
{
|
|
PeerDeletedMsg *p = (PeerDeletedMsg *) pMsg;
|
|
pSession->OnPeerDeletedNotification(p->m_lpPeerData);
|
|
}
|
|
break;
|
|
|
|
case EnumSubmitFileSendMsg:
|
|
{
|
|
SubmitFileSendMsg *p = (SubmitFileSendMsg *) pMsg;
|
|
if (p->m_EventHandle == pSession->GetEventHandle())
|
|
{
|
|
if(pSession->GetSessionType() == MBFT_PRIVATE_SEND_TYPE)
|
|
{
|
|
bWasHandled = TRUE;
|
|
((MBFTPrivateSend *) pSession)->SubmitFileSendRequest(p);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumFileTransferControlMsg:
|
|
{
|
|
FileTransferControlMsg *p = (FileTransferControlMsg *) pMsg;
|
|
if (p->m_EventHandle == pSession->GetEventHandle())
|
|
{
|
|
bWasHandled = TRUE;
|
|
pSession->OnControlNotification(
|
|
p->m_hFile,
|
|
p->m_ControlCommand,
|
|
p->m_szDirectory,
|
|
p->m_szFileName);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ASSERT(0);
|
|
break;
|
|
} // switch
|
|
|
|
if(bBroadcastFileOfferHack)
|
|
{
|
|
TRACE("(MBFT:) BroadcastFileOfferHack detected, aborting message processing\n");
|
|
break; //Out of message for loop
|
|
}
|
|
} //Message for loop
|
|
|
|
return TRUE; // delete the message
|
|
}
|
|
|
|
|
|
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
BOOL MBFTEngine::ConductedModeOK(void)
|
|
{
|
|
BOOL bReturn = TRUE;
|
|
|
|
if(m_bInConductedMode)
|
|
{
|
|
bReturn = (m_ConductedModePermission & PrivilegeRequestPDU::EnumFileTransfer) &&
|
|
(m_ConductedModePermission & PrivilegeRequestPDU::EnumPrivateChannel);
|
|
|
|
}
|
|
|
|
return(bReturn);
|
|
}
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
|
|
|
|
BOOL MBFTEngine::HandleSessionCreation(MBFTMsg *pMsg)
|
|
{
|
|
switch (pMsg->GetMsgType())
|
|
{
|
|
case EnumCreateSessionMsg:
|
|
{
|
|
CreateSessionMsg *p = (CreateSessionMsg *) pMsg;
|
|
MBFTSession *lpNewSession = NULL;
|
|
MBFTEVENTHANDLE EventHandle = p->m_EventHandle;
|
|
T120SessionID SessionID = p->m_SessionID;
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
BOOL bDeleteMessage = TRUE;
|
|
#endif
|
|
|
|
switch (p->m_iSessionType)
|
|
{
|
|
case MBFT_PRIVATE_SEND_TYPE:
|
|
if(m_State == IdleInitialized)
|
|
{
|
|
if(ConductedModeOK())
|
|
{
|
|
TRACESTATE(" Creating new acknowledged send session\n");
|
|
DBG_SAVE_FILE_LINE
|
|
lpNewSession = new MBFTPrivateSend(this,EventHandle,
|
|
m_uidMyself,
|
|
m_MBFTMaxSendDataPayload);
|
|
ASSERT(NULL != lpNewSession);
|
|
}
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
else
|
|
{
|
|
bDeleteMessage = FALSE;
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
TRACE(" Invalid attempt to create session before initialization\n");
|
|
}
|
|
break;
|
|
|
|
case MBFT_PRIVATE_RECV_TYPE:
|
|
if(m_State == IdleInitialized)
|
|
{
|
|
TRACESTATE(" Creating new acknowledge session\n");
|
|
DBG_SAVE_FILE_LINE
|
|
lpNewSession = new MBFTPrivateReceive(this,
|
|
EventHandle,
|
|
p->m_ControlChannel,
|
|
p->m_DataChannel);
|
|
ASSERT(NULL != lpNewSession);
|
|
}
|
|
else
|
|
{
|
|
TRACE(" Invalid attempt to create session before initialization\n");
|
|
}
|
|
break;
|
|
|
|
case MBFT_BROADCAST_RECV_TYPE:
|
|
#ifdef USE_BROADCAST_RECEIVE
|
|
if(m_State == IdleInitialized)
|
|
{
|
|
TRACESTATE(" Creating new broadcast receive session\n");
|
|
DBG_SAVE_FILE_LINE
|
|
lpNewSession = new MBFTBroadcastReceive(this,
|
|
EventHandle,
|
|
p->m_ControlChannel,
|
|
p->m_DataChannel,
|
|
p->m_SenderID,
|
|
p->m_FileHandle);
|
|
ASSERT(NULL != lpNewSession);
|
|
}
|
|
else
|
|
{
|
|
TRACE(" Invalid attempt to create session before initialization\n");
|
|
}
|
|
#endif // USE_BROADCAST_RECEIVE
|
|
break;
|
|
|
|
default:
|
|
ASSERT(0);
|
|
break;
|
|
} // switch
|
|
|
|
if (lpNewSession)
|
|
{
|
|
#ifdef ENABLE_HEARTBEAT_TIMER
|
|
if (lpNewSession->IsSendSession())
|
|
{
|
|
KillTimer(NULL, m_nTimerID);
|
|
m_nTimerID = ::SetTimer(NULL, 0, SESSION_TIMER_SPEED, HeartBeatTimerProc);
|
|
}
|
|
#endif
|
|
m_SessionList.Append(lpNewSession);
|
|
}
|
|
} // if create session message
|
|
break;
|
|
|
|
case EnumDeleteSessionMsg:
|
|
{
|
|
DeleteSessionMsg *p = (DeleteSessionMsg *) pMsg;
|
|
#ifdef ENABLE_HEARTBEAT_TIMER
|
|
if (NULL != p->m_lpDeleteSession)
|
|
{
|
|
if (p->m_lpDeleteSession->IsSendSession())
|
|
{
|
|
BOOL fSendSessExists = FALSE;
|
|
MBFTSession *pSess;
|
|
m_SessionList.Reset();
|
|
while (NULL != (pSess = m_SessionList.Iterate()))
|
|
{
|
|
if (pSess->IsSendSession())
|
|
{
|
|
fSendSessExists = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (! fSendSessExists)
|
|
{
|
|
::KillTimer(NULL, m_nTimerID);
|
|
m_nTimerID = ::SetTimer(NULL, 0, IDLE_TIMER_SPEED, HeartBeatTimerProc);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
m_SessionList.Delete(p->m_lpDeleteSession);
|
|
} // if delete session message
|
|
break;
|
|
|
|
default:
|
|
return FALSE; // not handled
|
|
}
|
|
|
|
return TRUE; // handled
|
|
}
|
|
|
|
|
|
BOOL MBFTEngine::DispatchPDUMessage(MBFTSession *lpMBFTSession,MBFTPDUMsg * lpNewMessage)
|
|
{
|
|
T120ChannelID wChannelID = lpNewMessage->m_wChannelId;
|
|
T120Priority iPriority = lpNewMessage->m_iPriority;
|
|
T120UserID SenderID = lpNewMessage->m_SenderID;
|
|
T120NodeID NodeID = GetNodeIdByUserID(SenderID);
|
|
BOOL IsUniformSendData = lpNewMessage->m_IsUniformSendData;
|
|
|
|
LPGENERICPDU lpNewPDU = lpNewMessage->m_lpNewPDU;
|
|
MBFTPDUType DecodedPDUType = lpNewMessage->m_PDUType;
|
|
|
|
BOOL bWasHandled = FALSE;
|
|
|
|
ASSERT(NULL != lpNewPDU);
|
|
switch(DecodedPDUType)
|
|
{
|
|
case EnumFileOfferPDU:
|
|
if (lpMBFTSession->IsReceiveSession())
|
|
{
|
|
MBFTPrivateReceive *pRecvSession = (MBFTPrivateReceive *) lpMBFTSession;
|
|
bWasHandled = pRecvSession->OnReceivedFileOfferPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
NodeID,
|
|
(LPFILEOFFERPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Offer PDU from [%u]\n",SenderID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumFileAcceptPDU:
|
|
if (lpMBFTSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) lpMBFTSession;
|
|
bWasHandled = pSendSession->OnReceivedFileAcceptPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILEACCEPTPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Accept PDU from [%u]\n",SenderID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumFileRejectPDU:
|
|
if (lpMBFTSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) lpMBFTSession;
|
|
bWasHandled = pSendSession->OnReceivedFileRejectPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILEREJECTPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Reject PDU from [%u]\n",SenderID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumFileAbortPDU:
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
if(m_bInConductedMode)
|
|
{
|
|
LPFILEABORTPDU lpAbortPDU = (LPFILEABORTPDU)lpNewPDU;
|
|
T120UserID MBFTUserID = lpAbortPDU->GetTransmitterID();
|
|
|
|
//MBFT 8.11.2
|
|
//If no MBFTUserID is specified, all providers must stop transmission...
|
|
|
|
if(!MBFTUserID)
|
|
{
|
|
AbortAllSends();
|
|
bWasHandled = TRUE;
|
|
}
|
|
else if(MBFTUserID == m_uidMyself)
|
|
{
|
|
//If only MBFTUserID is specified, all transmissions by that
|
|
//MBFT provider must cease....
|
|
|
|
if(!lpAbortPDU->GetFileHandle() && !lpAbortPDU->GetDataChannelID())
|
|
{
|
|
AbortAllSends();
|
|
bWasHandled = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (lpMBFTSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) lpMBFTSession;
|
|
bWasHandled = pSendSession->OnReceivedFileAbortPDU(
|
|
wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILEABORTPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Message was not meant for us...
|
|
bWasHandled = TRUE;
|
|
}
|
|
}
|
|
else
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
{
|
|
bWasHandled = TRUE;
|
|
}
|
|
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Abort PDU from [%u]\n",SenderID);
|
|
}
|
|
break;
|
|
|
|
case EnumFileStartPDU:
|
|
if (lpMBFTSession->IsReceiveSession())
|
|
{
|
|
MBFTPrivateReceive *pRecvSession = (MBFTPrivateReceive *) lpMBFTSession;
|
|
bWasHandled = pRecvSession->OnReceivedFileStartPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILESTARTPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Start PDU from [%u]\n",SenderID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumFileDataPDU:
|
|
if (lpMBFTSession->IsReceiveSession())
|
|
{
|
|
MBFTPrivateReceive *pRecvSession = (MBFTPrivateReceive *) lpMBFTSession;
|
|
bWasHandled = pRecvSession->OnReceivedFileDataPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILEDATAPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Data PDU from [%u]\n",SenderID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumPrivateChannelInvitePDU:
|
|
bWasHandled = TRUE;
|
|
TRACEPDU(" Private Channel Invite PDU from [%u]\n",SenderID);
|
|
break;
|
|
|
|
case EnumPrivateChannelResponsePDU:
|
|
if (lpMBFTSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) lpMBFTSession;
|
|
bWasHandled = pSendSession->OnReceivedPrivateChannelResponsePDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPPRIVATECHANNELRESPONSEPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" Private Channel Response PDU from [%u]\n",SenderID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumNonStandardPDU:
|
|
if (lpMBFTSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) lpMBFTSession;
|
|
bWasHandled = pSendSession->OnReceivedNonStandardPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPNONSTANDARDPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" Non Standard PDU from [%u]\n",SenderID);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EnumFileErrorPDU:
|
|
bWasHandled = lpMBFTSession->OnReceivedFileErrorPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILEERRORPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Error PDU from [%u]\n",SenderID);
|
|
}
|
|
break;
|
|
|
|
case EnumFileRequestPDU:
|
|
bWasHandled = OnReceivedFileRequestPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILEREQUESTPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" File Request PDU from [%u]\n",SenderID);
|
|
}
|
|
break;
|
|
|
|
case EnumFileDenyPDU:
|
|
TRACE(" *** WARNING (MBFT): Received File Deny PDU from [%u] *** \n",SenderID);
|
|
bWasHandled = TRUE;
|
|
break;
|
|
|
|
case EnumDirectoryRequestPDU:
|
|
bWasHandled = OnReceivedDirectoryRequestPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPDIRECTORYREQUESTPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
if(bWasHandled)
|
|
{
|
|
TRACEPDU(" DirectoryRequest PDU from [%u]\n",SenderID);
|
|
}
|
|
break;
|
|
|
|
case EnumDirectoryResponsePDU:
|
|
TRACE(" *** WARNING (MBFT): Received Directory Response PDU from [%u] *** \n",SenderID);
|
|
bWasHandled = TRUE;
|
|
break;
|
|
|
|
case EnumPrivilegeAssignPDU:
|
|
bWasHandled = OnReceivedPrivilegeAssignPDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPPRIVILEGEASSIGNPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
break;
|
|
|
|
#if 0
|
|
//Do not delete this code...
|
|
//It may become part of the MBFT standard in the future...
|
|
|
|
case EnumFileEndAcknowledgePDU:
|
|
if (lpMBFTSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) lpMBFTSession;
|
|
bWasHandled = pSendSession->OnReceivedFileEndAcknowledgePDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPFILEENDACKNOWLEDGEPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
}
|
|
break;
|
|
|
|
case EnumChannelLeavePDU:
|
|
if (lpMBFTSession->IsSendSession())
|
|
{
|
|
MBFTPrivateSend *pSendSession = (MBFTPrivateSend *) lpMBFTSession;
|
|
bWasHandled = pSendSession->OnReceivedChannelLeavePDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPCHANNELLEAVEPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
}
|
|
break;
|
|
//Do not delete this code...
|
|
//It may become part of the MBFT standard in the future...
|
|
#endif
|
|
|
|
default:
|
|
TRACE(" *** WARNING (MBFT): Unhandled PDU from [%u] *** \n",SenderID);
|
|
bWasHandled = TRUE; // LONCHANC: this should be false, right? why true?
|
|
break;
|
|
} // switch
|
|
|
|
return(bWasHandled);
|
|
}
|
|
|
|
|
|
BOOL MBFTEngine::OnReceivedPrivateChannelInvitePDU(T120ChannelID wChannelID,
|
|
T120Priority iPriority,
|
|
T120UserID SenderID,
|
|
LPPRIVATECHANNELINVITEPDU lpNewPDU,
|
|
BOOL IsUniformSendData)
|
|
{
|
|
if(m_State == IdleInitialized)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
MBFTMsg *pMsg = new CreateSessionMsg(MBFT_PRIVATE_RECV_TYPE,
|
|
::GetNewEventHandle(),
|
|
0,
|
|
lpNewPDU->GetControlChannel(),
|
|
lpNewPDU->GetDataChannel());
|
|
if (NULL != pMsg)
|
|
{
|
|
DoStateMachine(pMsg);
|
|
delete pMsg;
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
BOOL MBFTEngine::OnReceivedFileRequestPDU(T120ChannelID wChannelId,
|
|
T120Priority iPriority,
|
|
T120UserID SenderID,
|
|
LPFILEREQUESTPDU lpNewPDU,
|
|
BOOL IsUniformSendData)
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
LPFILEDENYPDU lpDenyPDU = new FileDenyPDU(lpNewPDU->GetRequestHandle());
|
|
if(lpDenyPDU)
|
|
{
|
|
if(lpDenyPDU->Encode())
|
|
{
|
|
if (SendDataRequest(SenderID, APPLET_HIGH_PRIORITY,
|
|
(LPBYTE)lpDenyPDU->GetBuffer(),
|
|
lpDenyPDU->GetBufferLength()))
|
|
{
|
|
bReturn = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return(bReturn);
|
|
}
|
|
|
|
BOOL MBFTEngine::OnReceivedDirectoryRequestPDU(T120ChannelID wChannelId,
|
|
T120Priority iPriority,
|
|
T120UserID SenderID,
|
|
LPDIRECTORYREQUESTPDU lpNewPDU,
|
|
BOOL IsUniformSendData)
|
|
{
|
|
BOOL bReturn = FALSE;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
LPDIRECTORYRESPONSEPDU lpDirPDU = new DirectoryResponsePDU();
|
|
if(lpDirPDU)
|
|
{
|
|
if(lpDirPDU->Encode())
|
|
{
|
|
if (SendDataRequest(SenderID, APPLET_HIGH_PRIORITY,
|
|
(LPBYTE)lpDirPDU->GetBuffer(),
|
|
lpDirPDU->GetBufferLength()))
|
|
{
|
|
bReturn = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return(bReturn);
|
|
}
|
|
|
|
BOOL MBFTEngine::OnReceivedPrivilegeAssignPDU(T120ChannelID wChannelId,
|
|
T120Priority iPriority,
|
|
T120UserID SenderID,
|
|
LPPRIVILEGEASSIGNPDU lpNewPDU,
|
|
BOOL IsUniformSendData)
|
|
{
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
if(m_bInConductedMode)
|
|
{
|
|
m_ConductedModePermission = lpNewPDU->GetPrivilegeWord();
|
|
}
|
|
#endif
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
void MBFTEngine::ApplyForPermission(void)
|
|
{
|
|
//m_bWaitingForPermission is set to make sure that we don't keep
|
|
//reapplying for permission until the conductor changes...
|
|
|
|
if(!m_bWaitingForPermission && m_bInConductedMode)
|
|
{
|
|
//MBFT 8.11.1
|
|
//If there is a MBFT conductor at the conducting node, we send
|
|
//a PrivilegeRequestPDU to the conductor....
|
|
|
|
if(m_MBFTConductorID)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
PrivilegeRequestPDU * lpNewPDU = new PrivilegeRequestPDU(PrivilegeRequestPDU::EnumFileTransfer |
|
|
PrivilegeRequestPDU::EnumPrivateChannel |
|
|
PrivilegeRequestPDU::EnumNonStandard);
|
|
if(lpNewPDU)
|
|
{
|
|
if(lpNewPDU->Encode())
|
|
{
|
|
if (SendDataRequest(m_MBFTConductorID, APPLET_HIGH_PRIORITY,
|
|
(LPBYTE)lpNewPDU->GetBuffer(),
|
|
lpNewPDU->GetBufferLength()))
|
|
{
|
|
m_bWaitingForPermission = TRUE;
|
|
}
|
|
}
|
|
|
|
delete lpNewPDU;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//MBFT 8.11.2
|
|
//Ask for permission via Node Controller...
|
|
}
|
|
}
|
|
}
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
|
|
|
|
BOOL MBFTEngine::DoStateMachine(MBFTMsg *pMsg)
|
|
{
|
|
BOOL fDeleteThisMessage = TRUE;
|
|
if (m_fConfAvailable)
|
|
{
|
|
BOOL fHandled = (NULL != pMsg) ? HandleSessionCreation(pMsg) : FALSE;
|
|
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
//Logic: If we are in the conducted mode, we check to see if
|
|
// we have sufficient privileges. If not, we make
|
|
// an attempt to secure the requisite privileges....
|
|
if(m_bInConductedMode)
|
|
{
|
|
if(!ConductedModeOK())
|
|
{
|
|
if(!m_bWaitingForPermission)
|
|
{
|
|
ApplyForPermission();
|
|
}
|
|
}
|
|
}
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
|
|
if (NULL != pMsg && ! fHandled)
|
|
{
|
|
fDeleteThisMessage = ProcessMessage(pMsg);
|
|
}
|
|
|
|
if (m_State == IdleInitialized && ! m_SessionList.IsEmpty())
|
|
{
|
|
CSessionList SessionListCopy(&m_SessionList);
|
|
MBFTSession *pSession;
|
|
while (NULL != (pSession = SessionListCopy.Get()))
|
|
{
|
|
pSession->DoStateMachine();
|
|
}
|
|
}
|
|
}
|
|
return fDeleteThisMessage;
|
|
}
|
|
|
|
|
|
//
|
|
// T120 Callback
|
|
//
|
|
|
|
|
|
void MBFTEngine::OnSendDataIndication
|
|
(
|
|
BOOL IsUniformSendData,
|
|
T120UserID SenderID,
|
|
T120ChannelID wChannelID,
|
|
T120Priority iPriority,
|
|
ULONG ulDataLength,
|
|
LPBYTE lpBuffer
|
|
)
|
|
{
|
|
GenericPDU * lpNewPDU = NULL;
|
|
LPCSTR lpDecodeBuffer = NULL;
|
|
BOOL bAddToPendingList = FALSE;
|
|
|
|
{
|
|
MBFTPDUType DecodedPDUType = GenericPDU::DecodePDU(
|
|
(LPSTR) lpBuffer,
|
|
ulDataLength,
|
|
&lpNewPDU,
|
|
&lpDecodeBuffer,
|
|
m_uidMyself,
|
|
m_pAppletSession);
|
|
if(DecodedPDUType != EnumUnknownPDU)
|
|
{
|
|
ASSERT (m_pAppletSession != NULL);
|
|
DBG_SAVE_FILE_LINE
|
|
MBFTPDUMsg * lpNewMessage = new MBFTPDUMsg(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
lpNewPDU,
|
|
IsUniformSendData,
|
|
DecodedPDUType,
|
|
(LPSTR)lpDecodeBuffer);
|
|
|
|
//Now that we have received a valid PDU, we must make sure that
|
|
//we know about this particular MBFT peer. If not, we add the PDU
|
|
//message to a different list....
|
|
|
|
if(IsValidPeerID(SenderID) && m_State == IdleInitialized)
|
|
{
|
|
//If the FileOffer is received on the default Control channel, it
|
|
//cannot be a private subsession send. Therefore, we create a special
|
|
//receive session to handle this case....
|
|
#ifdef USE_BROADCAST_RECEIVE
|
|
if(DecodedPDUType == EnumFileOfferPDU && wChannelID == m_MBFTControlChannel)
|
|
{
|
|
FileOfferPDU * lpFileOffer = (FileOfferPDU *)lpNewPDU;
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
MBFTMsg *pMsg = new CreateSessionMsg(MBFT_BROADCAST_RECV_TYPE,
|
|
::GetNewEventHandle(),
|
|
0,
|
|
m_MBFTControlChannel,
|
|
lpFileOffer->GetDataChannelID(),
|
|
SenderID,
|
|
lpFileOffer->GetFileHandle());
|
|
if (NULL != pMsg)
|
|
{
|
|
DoStateMachine(pMsg);
|
|
delete pMsg;
|
|
}
|
|
}
|
|
else
|
|
#endif // USE_BROADCAST_RECEIVE
|
|
|
|
if(DecodedPDUType == EnumPrivateChannelInvitePDU && wChannelID == m_uidMyself)
|
|
{
|
|
//In theory, the PrivateChannelInvitePDU marks the beginning of
|
|
//a PrivateSubsession receive. Therefore, we create one to handle all subsequent
|
|
//notifications....
|
|
|
|
OnReceivedPrivateChannelInvitePDU(wChannelID,
|
|
iPriority,
|
|
SenderID,
|
|
(LPPRIVATECHANNELINVITEPDU)lpNewPDU,
|
|
IsUniformSendData);
|
|
}
|
|
|
|
SafePostMessage(lpNewMessage);
|
|
} // if(IsValidPeerID(SenderID))
|
|
else
|
|
{
|
|
WARNING_OUT((" Received PDU from unknown peer [%u], adding to pending message list\n", (UINT) SenderID));
|
|
delete lpNewMessage;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE(" PDU Decoding Error or Invalid PDU\n");
|
|
|
|
}
|
|
|
|
// Unless this is one of the special 3 types of PDUs, we also
|
|
// need to free the MCS buffer. In the 3 special cases, the PDUs
|
|
// are responsible for freeing the buffer when they are done.
|
|
if ((DecodedPDUType != EnumFileDataPDU) &&
|
|
(DecodedPDUType != EnumNonStandardPDU) &&
|
|
(DecodedPDUType != EnumFileStartPDU))
|
|
{
|
|
m_pAppletSession->FreeSendDataBuffer((void *) lpBuffer);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void MBFTEngine::OnRosterReportIndication
|
|
(
|
|
ULONG cRosters,
|
|
GCCAppRoster *aAppRosters[] // array, size_is(cRosters)
|
|
)
|
|
{
|
|
TRACEGCC(" RosterReport: Session count %u\n", (UINT) cRosters);
|
|
|
|
UINT Index, PeerIndex, CapIndex;
|
|
LPCSTR lpszAppKey = NULL;
|
|
BOOL fConductorFound = FALSE;
|
|
|
|
CPeerList NewPeerList;
|
|
CPeerData *pOldPeer;
|
|
|
|
if (0 == cRosters) // not bloody likely
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (Index = 0; Index < cRosters; Index++ )
|
|
{
|
|
GCCAppRoster *pRoster = aAppRosters[Index];
|
|
if (pRoster->session_key.session_id != m_SessionID)
|
|
{
|
|
// this roster is not for our session...ignore it
|
|
continue;
|
|
}
|
|
|
|
//Added by Atul on 7/18 to fix missing roster instance bug...
|
|
m_nRosterInstance = pRoster->instance_number;
|
|
|
|
TRACEGCC( " Peer count [%u]\n", (UINT) pRoster->number_of_records );
|
|
|
|
for (PeerIndex = 0; PeerIndex < pRoster->number_of_records; PeerIndex++)
|
|
{
|
|
GCCAppRecord *pRecord = pRoster->application_record_list[PeerIndex];
|
|
lpszAppKey = NULL;
|
|
|
|
TRACE( "Local Entity ID [%u], Entity ID [%u], Node ID [%u], MBFTUser ID [%u]\n",
|
|
(UINT) m_eidMyself,
|
|
(UINT) pRecord->entity_id,
|
|
(UINT) pRecord->node_id,
|
|
(UINT) pRecord->application_user_id );
|
|
|
|
BOOL IsProshareNode = FALSE;
|
|
BOOL bEOFAcknowledgment = FALSE;
|
|
|
|
if (0 == Index)
|
|
{
|
|
for (CapIndex=0; CapIndex < pRoster->number_of_capabilities; CapIndex++)
|
|
{
|
|
GCCAppCap *pCap = pRoster->capabilities_list[CapIndex];
|
|
if (GCC_STANDARD_CAPABILITY != pCap->capability_id.capability_id_type)
|
|
{
|
|
continue;
|
|
}
|
|
switch (pCap->capability_id.standard_capability)
|
|
{
|
|
case _MBFT_MAX_FILE_SIZE_ID:
|
|
m_MBFTMaxFileSize = pCap->capability_class.nMinOrMax;
|
|
TRACEGCC( "max file size set to %u\n", (UINT) m_MBFTMaxFileSize );
|
|
break;
|
|
|
|
case _MBFT_MAX_DATA_PAYLOAD_ID:
|
|
m_MBFTMaxDataPayload = _iMBFT_DEFAULT_MAX_FILEDATA_PDU_LENGTH;
|
|
if (pCap->number_of_entities == pRoster->number_of_records)
|
|
{
|
|
m_MBFTMaxDataPayload = pCap->capability_class.nMinOrMax;
|
|
}
|
|
TRACEGCC( "max data payload set to %u\n", (UINT) m_MBFTMaxDataPayload );
|
|
break;
|
|
|
|
case _MBFT_V42_COMPRESSION_ID:
|
|
m_bV42CompressionSupported = (BOOL) (pCap->number_of_entities == pRoster->number_of_records);
|
|
TRACEGCC( "V.42bis compression is now %ssupported\n", m_bV42CompressionSupported ? "" : "not " );
|
|
break;
|
|
}
|
|
} // for CapIndex
|
|
} // if 0 == Index
|
|
|
|
// TODO: only check for 'ProShare node' if this node is new to us
|
|
for (CapIndex = 0; CapIndex < pRecord->number_of_non_collapsed_caps; CapIndex++)
|
|
{
|
|
GCCNonCollCap *pCap2 = pRecord->non_collapsed_caps_list[CapIndex];
|
|
if (GCC_STANDARD_CAPABILITY == pCap2->capability_id.capability_id_type)
|
|
{
|
|
if (_iMBFT_FIRST_PROSHARE_CAPABILITY_ID == pCap2->capability_id.standard_capability)
|
|
{
|
|
LPSTR pszData = (LPSTR) pCap2->application_data->value;
|
|
if (pCap2->application_data->length > sizeof(PROSHARE_STRING))
|
|
{
|
|
if (0 == ::memcmp(pszData, PROSHARE_STRING, sizeof(PROSHARE_STRING)))
|
|
{
|
|
IsProshareNode = TRUE;
|
|
lpszAppKey = &pszData[sizeof(PROSHARE_STRING)];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if (_iMBFT_PROSHARE_FILE_EOF_ACK_ID == pCap2->capability_id.standard_capability)
|
|
{
|
|
LPSTR pszData = (LPSTR) pCap2->application_data->value;
|
|
if (pCap2->application_data->length >= sizeof(PROSHARE_FILE_END_STRING) - 1)
|
|
{
|
|
if (0 == ::memcmp(pszData, PROSHARE_FILE_END_STRING, sizeof(PROSHARE_FILE_END_STRING) - 1))
|
|
{
|
|
bEOFAcknowledgment = TRUE;
|
|
}
|
|
}
|
|
}
|
|
} // if std cap
|
|
} // for CapIndex
|
|
|
|
BOOL IsLocalNode = (m_eidMyself == pRecord->entity_id) && (m_nidMyself == pRecord->node_id);
|
|
|
|
if( ( IdleNotInitialized == m_State )
|
|
&& IsLocalNode
|
|
&& pRecord->is_enrolled_actively )
|
|
{
|
|
m_State = IdleInitialized;
|
|
// m_uidMyself = pRecord->application_user_id;
|
|
m_MBFTControlChannel = m_SessionID;
|
|
}
|
|
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
if( m_bInConductedMode )
|
|
{
|
|
if (pRecord->node_id == m_ConductorNodeID &&
|
|
pRecord->is_conducting_capable)
|
|
{
|
|
//Now that we have found a conductor on the conducting node,
|
|
//our search is over....
|
|
|
|
//Make sure that the previously assigned conductor is still
|
|
//present in the roster report...
|
|
|
|
if( m_MBFTConductorID )
|
|
{
|
|
if( m_MBFTConductorID == pRecord->application_user_id )
|
|
{
|
|
fConductorFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//First time conductor assignment.....
|
|
m_MBFTConductorID = pRecord->application_user_id;
|
|
fConductorFound = TRUE;
|
|
if(m_ConductorNodeID != m_nidMyself)
|
|
{
|
|
m_ConductedModePermission = 0;
|
|
m_bWaitingForPermission = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
|
|
// build a new peer list
|
|
if (pRecord->is_enrolled_actively)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
CPeerData *lpPeer = new CPeerData(
|
|
pRecord->node_id,
|
|
pRecord->application_user_id,
|
|
IsLocalNode,
|
|
IsProshareNode,
|
|
pRecord->is_conducting_capable,
|
|
bEOFAcknowledgment,
|
|
lpszAppKey,
|
|
(DWORD)((pRecord->node_id == m_nidMyself)?((VER_PRODUCTVERSION_DW&0xffff0000)>>16):
|
|
T120_GetNodeVersion(m_nConfID, pRecord->node_id)));
|
|
if (NULL == lpPeer)
|
|
{
|
|
ASSERT(0);
|
|
return;
|
|
}
|
|
NewPeerList.Append(lpPeer);
|
|
pOldPeer = m_PeerList.FindSamePeer(lpPeer);
|
|
if (NULL != pOldPeer)
|
|
{
|
|
// we already new about this peer
|
|
m_PeerList.Delete(pOldPeer);
|
|
}
|
|
else
|
|
{
|
|
// this is a new peer
|
|
AddPeerNotification(
|
|
pRecord->node_id,
|
|
pRecord->application_user_id,
|
|
IsLocalNode,
|
|
IsProshareNode,
|
|
TRUE,
|
|
lpszAppKey ? lpszAppKey : "", // TODO: address appkey issue here; needed?
|
|
pRoster->session_key.session_id );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef ENABLE_CONDUCTORSHIP
|
|
//If we are on the conducting node, we need no privileges...
|
|
if (m_bInConductedMode && (m_ConductorNodeID != m_nidMyself))
|
|
{
|
|
//MBFT 8.11.1
|
|
//If the previously assigned conductor is not present in the roster report,
|
|
//all privileges are revoked and we should abort all sends...
|
|
if( !fConductorFound )
|
|
{
|
|
AbortAllSends();
|
|
}
|
|
}
|
|
#endif // ENABLE_CONDUCTORSHIP
|
|
|
|
while (NULL != (pOldPeer = m_PeerList.Get()))
|
|
{
|
|
AddPeerNotification(
|
|
pOldPeer->GetNodeID(),
|
|
pOldPeer->GetUserID(),
|
|
pOldPeer->GetIsLocalNode(),
|
|
pOldPeer->GetIsProshareNode(),
|
|
FALSE,
|
|
MY_APP_STR,
|
|
m_SessionID );
|
|
|
|
DBG_SAVE_FILE_LINE
|
|
CPeerData *p = new CPeerData(
|
|
pOldPeer->GetNodeID(),
|
|
pOldPeer->GetUserID(),
|
|
pOldPeer->GetIsLocalNode(),
|
|
pOldPeer->GetIsProshareNode(),
|
|
pOldPeer->GetCanConduct(),
|
|
pOldPeer->GetEOFAcknowledge(),
|
|
pOldPeer->GetAppKey(),
|
|
pOldPeer->GetVersion());
|
|
ASSERT(NULL != p);
|
|
if (p)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
SafePostMessage(new PeerDeletedMsg(p));
|
|
}
|
|
TRACEGCC("Peer Removed: Node [%u], UserID [%u]\n", pOldPeer->GetNodeID(), pOldPeer->GetUserID() );
|
|
delete pOldPeer;
|
|
}
|
|
|
|
while (NULL != (pOldPeer = NewPeerList.Get()))
|
|
{
|
|
m_PeerList.Append(pOldPeer);
|
|
}
|
|
|
|
// notify UI of new rosters
|
|
if (NULL != m_pWindow)
|
|
{
|
|
m_pWindow->UpdateUI();
|
|
}
|
|
}
|
|
|
|
|
|
void MBFTEngine::OnChannelAdmitIndication
|
|
(
|
|
T120ChannelID nChannelID,
|
|
T120UserID nManagerID
|
|
)
|
|
{
|
|
if (IsValidPeerID(nManagerID) && m_State == IdleInitialized)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
SafePostMessage(new MCSChannelAdmitIndicationMsg(nChannelID, nManagerID));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CALLBACK T120Callback
|
|
(
|
|
T120AppletSessionMsg *pMsg
|
|
)
|
|
{
|
|
MBFTEngine *pEngine = (MBFTEngine *) pMsg->pSessionContext;
|
|
ASSERT(NULL != pEngine);
|
|
|
|
BOOL fSuccess;
|
|
T120ChannelID nChannelID;
|
|
|
|
switch (pMsg->eMsgType)
|
|
{
|
|
case T120_JOIN_SESSION_CONFIRM:
|
|
pEngine->OnJoinSessionConfirm(&pMsg->JoinSessionConfirm);
|
|
break;
|
|
|
|
case GCC_APP_ROSTER_REPORT_INDICATION:
|
|
pEngine->OnRosterReportIndication(pMsg->AppRosterReportInd.cRosters,
|
|
pMsg->AppRosterReportInd.apAppRosters);
|
|
break;
|
|
|
|
// case GCC_APPLICATION_INVOKE_CONFIRM:
|
|
// break;
|
|
|
|
case MCS_SEND_DATA_INDICATION:
|
|
case MCS_UNIFORM_SEND_DATA_INDICATION:
|
|
pEngine->OnSendDataIndication(
|
|
(pMsg->eMsgType == MCS_UNIFORM_SEND_DATA_INDICATION),
|
|
pMsg->SendDataInd.initiator,
|
|
pMsg->SendDataInd.channel_id,
|
|
(T120Priority) pMsg->SendDataInd.data_priority,
|
|
pMsg->SendDataInd.user_data.length,
|
|
pMsg->SendDataInd.user_data.value);
|
|
break;
|
|
|
|
case MCS_CHANNEL_JOIN_CONFIRM:
|
|
fSuccess = (T120_RESULT_SUCCESSFUL == pMsg->ChannelConfirm.eResult);
|
|
DBG_SAVE_FILE_LINE
|
|
pEngine->SafePostMessage(new MCSChannelJoinConfirmMsg(pMsg->ChannelConfirm.nChannelID, fSuccess));
|
|
break;
|
|
|
|
case MCS_CHANNEL_CONVENE_CONFIRM:
|
|
fSuccess = (T120_RESULT_SUCCESSFUL == pMsg->ChannelConfirm.eResult);
|
|
DBG_SAVE_FILE_LINE
|
|
pEngine->SafePostMessage(new MCSChannelConveneConfirmMsg(pMsg->ChannelConfirm.nChannelID, fSuccess));
|
|
break;
|
|
|
|
// case MCS_CHANNEL_LEAVE_INDICATION:
|
|
// break;
|
|
|
|
// case MCS_CHANNEL_DISBAND_INDICATION:
|
|
// break;
|
|
|
|
case MCS_CHANNEL_ADMIT_INDICATION:
|
|
pEngine->OnChannelAdmitIndication(pMsg->ChannelInd.nChannelID, pMsg->ChannelInd.nManagerID);
|
|
break;
|
|
|
|
case MCS_CHANNEL_EXPEL_INDICATION:
|
|
DBG_SAVE_FILE_LINE
|
|
pEngine->SafePostMessage(new MCSChannelExpelIndicationMsg(pMsg->ChannelInd.nChannelID, pMsg->ChannelInd.eReason));
|
|
break;
|
|
|
|
// case MCS_TOKEN_GRAB_CONFIRM:
|
|
// case MCS_TOKEN_INHIBIT_CONFIRM:
|
|
// case MCS_TOKEN_GIVE_CONFIRM:
|
|
// case MCS_TOKEN_RELEASE_CONFIRM:
|
|
// case MCS_TOKEN_TEST_CONFIRM:
|
|
// break;
|
|
|
|
// case MCS_TOKEN_GIVE_INDICATION:
|
|
// case MCS_TOKEN_PLEASE_INDICATION:
|
|
// case MCS_TOKEN_RELEASE_INDICATION:
|
|
// break;
|
|
|
|
case MCS_DETACH_USER_INDICATION:
|
|
pEngine->OnDetachUserIndication(pMsg->DetachUserInd.nUserID, pMsg->DetachUserInd.eReason);
|
|
break;
|
|
|
|
case MCS_TRANSMIT_BUFFER_AVAILABLE_INDICATION:
|
|
g_fWaitingForBufferAvailable = FALSE;
|
|
::PostMessage(g_pFileXferApplet->GetHiddenWnd(),
|
|
MBFTMSG_HEART_BEAT, 0, (LPARAM) pEngine);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL MBFTEngine::SimpleChannelRequest
|
|
(
|
|
AppletChannelCommand eCommand,
|
|
T120ChannelID nChannelID
|
|
)
|
|
{
|
|
T120ChannelRequest req;
|
|
::ZeroMemory(&req, sizeof(req));
|
|
req.eCommand = eCommand;
|
|
req.nChannelID = nChannelID;
|
|
T120Error rc = m_pAppletSession->ChannelRequest(&req);
|
|
return (T120_NO_ERROR == rc);
|
|
}
|
|
|
|
T120NodeID MBFTEngine::GetNodeIdByUserID(T120UserID nUserID)
|
|
{
|
|
CPeerData *p;
|
|
m_PeerList.Reset();
|
|
while (NULL != (p = m_PeerList.Iterate()))
|
|
{
|
|
if (nUserID == p->GetUserID())
|
|
{
|
|
return p->GetNodeID();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
BOOL MBFTEngine::MCSChannelAdmitRequest
|
|
(
|
|
T120ChannelID nChannelID,
|
|
T120UserID *aUsers,
|
|
ULONG cUsers
|
|
)
|
|
{
|
|
T120ChannelRequest req;
|
|
::ZeroMemory(&req, sizeof(req));
|
|
req.eCommand = APPLET_ADMIT_CHANNEL;
|
|
req.nChannelID = nChannelID;
|
|
req.cUsers = cUsers;
|
|
req.aUsers = aUsers;
|
|
T120Error rc = m_pAppletSession->ChannelRequest(&req);
|
|
return (T120_NO_ERROR == rc);
|
|
}
|
|
|
|
BOOL MBFTEngine::SendDataRequest
|
|
(
|
|
T120ChannelID nChannelID,
|
|
T120Priority ePriority,
|
|
LPBYTE pBuffer,
|
|
ULONG cbBufSize
|
|
)
|
|
{
|
|
if (m_eLastSendDataError == MCS_TRANSMIT_BUFFER_FULL)
|
|
{
|
|
if (g_fWaitingForBufferAvailable == FALSE)
|
|
{
|
|
m_eLastSendDataError = MCS_NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
TRACEMCS("MBFTEngine::SendDataReques still waiting for a MCS_TRANSMIT_BUFFER_AVAILABLE_INDICATION");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
m_eLastSendDataError = m_pAppletSession->SendData(
|
|
NORMAL_SEND_DATA, nChannelID, ePriority,
|
|
pBuffer, cbBufSize, APP_ALLOCATION);
|
|
//
|
|
// T120 is busy and can't allocate data
|
|
//
|
|
if (m_eLastSendDataError == MCS_TRANSMIT_BUFFER_FULL)
|
|
{
|
|
g_fWaitingForBufferAvailable = TRUE;
|
|
TRACEMCS("MCSSendDataRequest failed we will not send data until we get a MCS_TRANSMIT_BUFFER_AVAILABLE_INDICATION");
|
|
}
|
|
|
|
return (T120_NO_ERROR == m_eLastSendDataError);
|
|
}
|
|
|
|
|
|
//
|
|
// CPeerList
|
|
//
|
|
|
|
CPeerData * CPeerList::Find(T120NodeID nNodeID)
|
|
{
|
|
CPeerData *p;
|
|
Reset();
|
|
while (NULL != (p = Iterate()))
|
|
{
|
|
if (p->GetUserID() == nNodeID)
|
|
{
|
|
return p;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CPeerData * CPeerList::FindSamePeer(CPeerData *pPeer)
|
|
{
|
|
CPeerData *p;
|
|
Reset();
|
|
while (NULL != (p = Iterate()))
|
|
{
|
|
if (pPeer->GetNodeID() == p->GetNodeID() && pPeer->GetUserID() == p->GetUserID())
|
|
{
|
|
return p;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void CPeerList::Delete(CPeerData *p)
|
|
{
|
|
if (Remove(p))
|
|
{
|
|
delete p;
|
|
}
|
|
}
|
|
|
|
void CPeerList::DeleteAll(void)
|
|
{
|
|
CPeerData *p;
|
|
while (NULL != (p = Get()))
|
|
{
|
|
delete p;
|
|
}
|
|
}
|
|
|
|
|
|
void CSessionList::Delete(MBFTSession *p)
|
|
{
|
|
if (Remove(p))
|
|
{
|
|
delete p;
|
|
}
|
|
}
|
|
|
|
|
|
// thought it is a pure virtual, we still need a destructor
|
|
MBFTSession::~MBFTSession(void) { }
|
|
|
|
|
|
HRESULT MBFTEngine::SafePostNotifyMessage(MBFTMsg *p)
|
|
{
|
|
// notify applet UI if it exists
|
|
if (NULL != m_pWindow)
|
|
{
|
|
m_pWindow->OnEngineNotify(p);
|
|
}
|
|
|
|
if (NULL != m_pMBFTIntf)
|
|
{
|
|
return m_pMBFTIntf->SafePostNotifyMessage(p);
|
|
}
|
|
|
|
delete p;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
MBFTEVENTHANDLE GetNewEventHandle(void)
|
|
{
|
|
static ULONG s_nEventHandle = 0x55AA;
|
|
ULONG nEvtHdl;
|
|
|
|
::EnterCriticalSection(&g_csWorkThread);
|
|
if (s_nEventHandle > 0xFFFF)
|
|
{
|
|
s_nEventHandle = 0x55AA;
|
|
}
|
|
nEvtHdl = s_nEventHandle++;
|
|
::LeaveCriticalSection(&g_csWorkThread);
|
|
|
|
return nEvtHdl;
|
|
}
|
|
|
|
|
|
MBFTFILEHANDLE GetNewFileHandle(void)
|
|
{
|
|
static ULONG s_nFileHandle = 1;
|
|
ULONG nFileHdl;
|
|
|
|
::EnterCriticalSection(&g_csWorkThread);
|
|
if (s_nFileHandle > 0xFFFF)
|
|
{
|
|
s_nFileHandle = 0x1;
|
|
}
|
|
nFileHdl = s_nFileHandle++;
|
|
::LeaveCriticalSection(&g_csWorkThread);
|
|
|
|
return nFileHdl;
|
|
}
|
|
|
|
|
|
|