windows-server-2003/enduser/netmeeting/ui/msconfft/mbft.cpp

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