5873 lines
148 KiB
C++
5873 lines
148 KiB
C++
#include "precomp.h"
|
||
DEBUG_FILEZONE(ZONE_T120_GCCNC);
|
||
/*
|
||
* conf2.cpp
|
||
*
|
||
* Copyright (c) 1995 by DataBeam Corporation, Lexington, KY
|
||
*
|
||
* Abstract:
|
||
* This is the second part of the imlementation file for the CConf
|
||
* Class. The conference class is the heart of GCC. It maintains all the
|
||
* information basses for a single conference including conference and
|
||
* application rosters as well as registry information. It also
|
||
* routes, encodes and decodes various PDU's and primitives supported
|
||
* by GCC.
|
||
*
|
||
* This second part of the implementation file deals mainly with the
|
||
* command target calls and any callbacks received by the Owner Callback
|
||
* function. It also contains many of the utility functions used by the
|
||
* conference object.
|
||
*
|
||
* FOR A MORE DETAILED EXPLANATION OF THIS CLASS SEE THE INTERFACE FILE.
|
||
*
|
||
*
|
||
* Private Instance Variables
|
||
*
|
||
* ALL PRIVATE INSTANCE VARIABLES ARE DEFINED IN CONF.CPP
|
||
*
|
||
* Portable:
|
||
* Yes
|
||
*
|
||
* Caveats:
|
||
* None.
|
||
*
|
||
* Author:
|
||
* blp
|
||
*/
|
||
|
||
#include "conf.h"
|
||
#include "gcontrol.h"
|
||
#include "translat.h"
|
||
#include "ogcccode.h"
|
||
#include "string.h"
|
||
|
||
|
||
#define TERMINATE_TIMER_DURATION 10000 // Duration in milliseconds
|
||
|
||
static const struct ASN1objectidentifier_s WB_ASN1_OBJ_IDEN[6] = {
|
||
{ (ASN1objectidentifier_t) &(WB_ASN1_OBJ_IDEN[1]), 0 },
|
||
{ (ASN1objectidentifier_t) &(WB_ASN1_OBJ_IDEN[2]), 0 },
|
||
{ (ASN1objectidentifier_t) &(WB_ASN1_OBJ_IDEN[3]), 20 },
|
||
{ (ASN1objectidentifier_t) &(WB_ASN1_OBJ_IDEN[4]), 126 },
|
||
{ (ASN1objectidentifier_t) &(WB_ASN1_OBJ_IDEN[5]), 0 },
|
||
{ NULL, 1 }
|
||
};
|
||
|
||
static const struct Key WB_APP_PROTO_KEY = {
|
||
1, (ASN1objectidentifier_t)&WB_ASN1_OBJ_IDEN};
|
||
|
||
|
||
static const struct ASN1objectidentifier_s FT_ASN1_OBJ_IDEN[6] = {
|
||
{ (ASN1objectidentifier_t) &(FT_ASN1_OBJ_IDEN[1]), 0 },
|
||
{ (ASN1objectidentifier_t) &(FT_ASN1_OBJ_IDEN[2]), 0 },
|
||
{ (ASN1objectidentifier_t) &(FT_ASN1_OBJ_IDEN[3]), 20 },
|
||
{ (ASN1objectidentifier_t) &(FT_ASN1_OBJ_IDEN[4]), 127 },
|
||
{ (ASN1objectidentifier_t) &(FT_ASN1_OBJ_IDEN[5]), 0 },
|
||
{ NULL, 1 }
|
||
};
|
||
|
||
static const struct Key FT_APP_PROTO_KEY = {
|
||
1, (ASN1objectidentifier_t)&FT_ASN1_OBJ_IDEN};
|
||
|
||
|
||
struct Key CHAT_APP_PROTO_KEY;
|
||
|
||
|
||
/*
|
||
* This is a global variable that has a pointer to the one GCC coder that
|
||
* is instantiated by the GCC Controller. Most objects know in advance
|
||
* whether they need to use the MCS or the GCC coder, so, they do not need
|
||
* this pointer in their constructors.
|
||
*/
|
||
extern CGCCCoder *g_GCCCoder;
|
||
|
||
extern MCSDLLInterface *g_pMCSIntf;
|
||
|
||
/*
|
||
** These are GCCCommandTarget Calls. The only command targets that
|
||
** conference is connected to are Application SAPs and the Control SAP, so
|
||
** these Public member functions are only called from above.
|
||
*/
|
||
|
||
/*
|
||
* CConf::ConfJoinReqResponse()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called when a node controller responds to a join
|
||
* request that was issued by a join from a node connected to a subnode.
|
||
*/
|
||
GCCError CConf::
|
||
ConfJoinReqResponse
|
||
(
|
||
UserID receiver_id,
|
||
CPassword *password_challenge,
|
||
CUserDataListContainer *user_data_list,
|
||
GCCResult result
|
||
)
|
||
{
|
||
DebugEntry(CConf::ConfJoinReqResponse);
|
||
|
||
/*
|
||
** Since the joining node is not directly connected to this
|
||
** node we send the response back through the user channel.
|
||
** It is the user attachment objects responsibility to
|
||
** encode this PDU.
|
||
*/
|
||
if (m_pMcsUserObject != NULL)
|
||
{
|
||
m_pMcsUserObject->ConferenceJoinResponse(
|
||
receiver_id,
|
||
m_fClearPassword,
|
||
m_fConfLocked,
|
||
m_fConfListed,
|
||
m_eTerminationMethod,
|
||
password_challenge,
|
||
user_data_list,
|
||
result);
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfJoinReqResponse, GCC_NO_ERROR);
|
||
return (GCC_NO_ERROR);
|
||
}
|
||
|
||
/*
|
||
* CConf::ConfInviteRequest()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a
|
||
* ConfInviteRequest primitive needs to be processed.
|
||
*/
|
||
GCCError CConf::
|
||
ConfInviteRequest
|
||
(
|
||
LPWSTR pwszCallerID,
|
||
TransportAddress calling_address,
|
||
TransportAddress called_address,
|
||
BOOL fSecure,
|
||
CUserDataListContainer *user_data_list,
|
||
PConnectionHandle connection_handle
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
PUChar encoded_pdu;
|
||
UINT encoded_pdu_length;
|
||
MCSError mcs_error;
|
||
ConnectGCCPDU connect_pdu;
|
||
INVITE_REQ_INFO *invite_request_info;
|
||
|
||
DebugEntry(CConf::ConfInviteRequest);
|
||
|
||
if (! m_fConfIsEstablished)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: Conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** If the conference is locked, we only allow invite request if there
|
||
** are outstanding adds. T.124 states that when a conference is
|
||
** locked you can only use ADD to bring in new nodes to the conference.
|
||
*/
|
||
if (m_fConfLocked && m_AddResponseList.IsEmpty())
|
||
{
|
||
WARNING_OUT(("CConf::ConfInviteRequest: Conference is locked"));
|
||
rc = GCC_INVALID_CONFERENCE;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create the ConfInviteRequest PDU here.
|
||
connect_pdu.choice = CONFERENCE_INVITE_REQUEST_CHOSEN;
|
||
|
||
connect_pdu.u.conference_invite_request.bit_mask = 0;
|
||
|
||
/*
|
||
** First get the numeric and text (if it exists) portion of the
|
||
** conference name.
|
||
*/
|
||
connect_pdu.u.conference_invite_request.conference_name.bit_mask =0;
|
||
|
||
::lstrcpyA(connect_pdu.u.conference_invite_request.conference_name.numeric,
|
||
m_pszConfNumericName);
|
||
|
||
if (m_pwszConfTextName != NULL)
|
||
{
|
||
connect_pdu.u.conference_invite_request.conference_name.bit_mask |=
|
||
CONFERENCE_NAME_TEXT_PRESENT;
|
||
connect_pdu.u.conference_invite_request.conference_name.conference_name_text.value =
|
||
m_pwszConfTextName;
|
||
connect_pdu.u.conference_invite_request.conference_name.conference_name_text.length =
|
||
::lstrlenW(m_pwszConfTextName);
|
||
}
|
||
|
||
// Now set up the privilege list PDU data
|
||
if (m_pConductorPrivilegeList != NULL)
|
||
{
|
||
rc = m_pConductorPrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.conference_invite_request.cirq_conductor_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: can't get conductor privilege list, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_invite_request.bit_mask |= CIRQ_CONDUCTOR_PRIVS_PRESENT;
|
||
}
|
||
|
||
if (m_pConductModePrivilegeList != NULL)
|
||
{
|
||
rc = m_pConductModePrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.conference_invite_request.cirq_conducted_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: can't get conduct mode privilege list, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_invite_request.bit_mask |= CIRQ_CONDUCTED_PRIVS_PRESENT;
|
||
}
|
||
|
||
|
||
if (m_pNonConductModePrivilegeList != NULL)
|
||
{
|
||
rc = m_pNonConductModePrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.conference_invite_request.cirq_non_conducted_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: can't get non-conduct mode privilege list, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_invite_request.bit_mask |= CIRQ_NON_CONDUCTED_PRIVS_PRESENT;
|
||
}
|
||
|
||
if (m_pwszConfDescription != NULL)
|
||
{
|
||
connect_pdu.u.conference_invite_request.cirq_description.value =
|
||
m_pwszConfDescription;
|
||
connect_pdu.u.conference_invite_request.cirq_description.length =
|
||
::lstrlenW(m_pwszConfDescription);
|
||
|
||
connect_pdu.u.conference_invite_request.bit_mask |= CIRQ_DESCRIPTION_PRESENT;
|
||
}
|
||
|
||
if (pwszCallerID != NULL)
|
||
{
|
||
connect_pdu.u.conference_invite_request.cirq_caller_id.value = pwszCallerID;
|
||
connect_pdu.u.conference_invite_request.cirq_caller_id.length = ::lstrlenW(pwszCallerID);
|
||
connect_pdu.u.conference_invite_request.bit_mask |= CIRQ_CALLER_ID_PRESENT;
|
||
}
|
||
|
||
if (user_data_list != NULL)
|
||
{
|
||
rc = user_data_list->GetUserDataPDU(
|
||
&connect_pdu.u.conference_invite_request.cirq_user_data);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: can't get user data, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_invite_request.bit_mask |= CIRQ_USER_DATA_PRESENT;
|
||
}
|
||
|
||
connect_pdu.u.conference_invite_request.node_id = m_pMcsUserObject->GetMyNodeID();
|
||
connect_pdu.u.conference_invite_request.top_node_id = m_pMcsUserObject->GetTopNodeID();
|
||
connect_pdu.u.conference_invite_request.tag = GetNewUserIDTag();
|
||
connect_pdu.u.conference_invite_request.clear_password_required = (ASN1bool_t)m_fClearPassword;
|
||
connect_pdu.u.conference_invite_request.conference_is_locked = (ASN1bool_t)m_fConfLocked;
|
||
connect_pdu.u.conference_invite_request.conference_is_conductible = (ASN1bool_t)m_fConfConductible;
|
||
connect_pdu.u.conference_invite_request.conference_is_listed = (ASN1bool_t)m_fConfListed;
|
||
connect_pdu.u.conference_invite_request.termination_method = (TerminationMethod)m_eTerminationMethod;
|
||
|
||
if (! g_GCCCoder->Encode((LPVOID) &connect_pdu,
|
||
CONNECT_GCC_PDU,
|
||
PACKED_ENCODING_RULES,
|
||
&encoded_pdu,
|
||
&encoded_pdu_length))
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: can't encode"));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
goto MyExit;
|
||
}
|
||
|
||
mcs_error = g_pMCSIntf->ConnectProviderRequest (
|
||
&m_nConfID, // calling domain selector
|
||
&m_nConfID, // called domain selector
|
||
calling_address,
|
||
called_address,
|
||
fSecure,
|
||
FALSE, // Downward connection
|
||
encoded_pdu,
|
||
encoded_pdu_length,
|
||
connection_handle,
|
||
m_pDomainParameters,
|
||
this);
|
||
|
||
g_GCCCoder->FreeEncoded(encoded_pdu);
|
||
|
||
if (MCS_NO_ERROR != mcs_error)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: ConnectProviderRequest failed: rc=%d", mcs_error));
|
||
|
||
/*
|
||
** DataBeam's current implementation of MCS returns
|
||
** MCS_INVALID_PARAMETER when something other than
|
||
** the transport prefix is wrong with the specified
|
||
** transport address.
|
||
*/
|
||
rc = (mcs_error == MCS_INVALID_PARAMETER) ?
|
||
GCC_INVALID_TRANSPORT_ADDRESS :
|
||
g_pMCSIntf->TranslateMCSIFErrorToGCCError(mcs_error);
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** Add the user's tag number to the list of
|
||
** outstanding user ids along with its associated
|
||
** connection.
|
||
*/
|
||
m_ConnHdlTagNumberList2.Append(connect_pdu.u.conference_invite_request.tag, *connection_handle);
|
||
|
||
// Add connection handle to the list of connections
|
||
ASSERT(0 != *connection_handle);
|
||
m_ConnHandleList.Append(*connection_handle);
|
||
|
||
/*
|
||
** Add the connection handle and the Node Id tag to
|
||
** the list of outstanding invite request.
|
||
*/
|
||
DBG_SAVE_FILE_LINE
|
||
invite_request_info = new INVITE_REQ_INFO;
|
||
if (NULL == invite_request_info)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteRequest: can't create invite request info"));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
goto MyExit;
|
||
}
|
||
|
||
invite_request_info->connection_handle = *connection_handle;
|
||
invite_request_info->invite_tag = m_nUserIDTagNumber;
|
||
invite_request_info->user_data_list = NULL;
|
||
|
||
m_InviteRequestList.Append(invite_request_info);
|
||
|
||
// Free the privilege list packed into structures for encoding
|
||
if (connect_pdu.u.conference_invite_request.bit_mask & CIRQ_CONDUCTOR_PRIVS_PRESENT)
|
||
{
|
||
m_pConductorPrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.conference_invite_request.cirq_conductor_privs);
|
||
}
|
||
|
||
if (connect_pdu.u.conference_invite_request.bit_mask & CIRQ_CONDUCTED_PRIVS_PRESENT)
|
||
{
|
||
m_pConductModePrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.conference_invite_request.cirq_conducted_privs);
|
||
}
|
||
|
||
if (connect_pdu.u.conference_invite_request.bit_mask & CIRQ_NON_CONDUCTED_PRIVS_PRESENT)
|
||
{
|
||
m_pNonConductModePrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.conference_invite_request.cirq_non_conducted_privs);
|
||
}
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::ConfInviteRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
/*
|
||
* CConf::ConfLockRequest()
|
||
*
|
||
* Public Function Description:
|
||
* This routine is called from Control Sap when a
|
||
* ConfLockRequest primitive needs to be processed.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfLockRequest ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfLockRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (m_fConfLocked == CONFERENCE_IS_NOT_LOCKED)
|
||
{
|
||
if (IsConfTopProvider())
|
||
{
|
||
ProcessConferenceLockRequest((UserID)m_pMcsUserObject->GetMyNodeID());
|
||
}
|
||
else
|
||
{
|
||
rc = m_pMcsUserObject->SendConferenceLockRequest();
|
||
}
|
||
}
|
||
else // the conference is already locked
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfLockConfirm(GCC_RESULT_CONFERENCE_ALREADY_LOCKED, m_nConfID);
|
||
#endif // JASPER
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfLockRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfLockRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* CConf::ConfLockResponse()
|
||
*
|
||
* Public Function Description:
|
||
* This routine is called from Control Sap when a
|
||
* ConfLockResponse primitive needs to be processed.
|
||
*/
|
||
GCCError CConf::
|
||
ConfLockResponse
|
||
(
|
||
UserID requesting_node,
|
||
GCCResult result
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfLockResponse);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (requesting_node == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfLockConfirm(result, m_nConfID);
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
rc = m_pMcsUserObject->SendConferenceLockResponse(requesting_node, result);
|
||
}
|
||
|
||
if (rc == GCC_NO_ERROR && result == GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
m_fConfLocked = CONFERENCE_IS_LOCKED;
|
||
rc = m_pMcsUserObject->SendConferenceLockIndication(
|
||
TRUE, //indicates uniform send
|
||
0);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfLockResponse: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfLockResponse, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ConfUnlockRequest()
|
||
*
|
||
* Public Function Description:
|
||
* This routine is called from Control Sap when a
|
||
* ConferenceUnlockRequest primitive needs to be processed.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfUnlockRequest ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfUnlockRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (m_fConfLocked == CONFERENCE_IS_LOCKED)
|
||
{
|
||
if (IsConfTopProvider())
|
||
{
|
||
ProcessConferenceUnlockRequest((UserID)m_pMcsUserObject->GetMyNodeID());
|
||
}
|
||
else
|
||
{
|
||
rc = m_pMcsUserObject->SendConferenceUnlockRequest();
|
||
}
|
||
}
|
||
else // the conference is already unlocked
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfUnlockConfirm(GCC_RESULT_CONFERENCE_ALREADY_UNLOCKED, m_nConfID);
|
||
#endif // JASPER
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfUnlockRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfUnlockRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* CConf::ConfUnlockResponse()
|
||
*
|
||
* Public Function Description:
|
||
* This routine is called from Control Sap when a
|
||
* ConfUnlockResponse primitive needs to be processed.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfUnlockResponse
|
||
(
|
||
UserID requesting_node,
|
||
GCCResult result
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfUnlockResponse);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (requesting_node == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfUnlockConfirm(result, m_nConfID);
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
rc = m_pMcsUserObject->SendConferenceUnlockResponse(requesting_node, result);
|
||
}
|
||
|
||
if (rc == GCC_NO_ERROR && result == GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
m_fConfLocked = CONFERENCE_IS_NOT_LOCKED;
|
||
rc = m_pMcsUserObject->SendConferenceUnlockIndication(
|
||
TRUE, //indicates uniform send
|
||
0);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfUnlockResponse: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfUnlockResponse, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
/*
|
||
* CConf::ConfEjectUserRequest ()
|
||
*
|
||
* Private Function Description
|
||
* This function initiates an eject user for the specified node id.
|
||
*/
|
||
GCCError CConf::
|
||
ConfEjectUserRequest
|
||
(
|
||
UserID ejected_node_id,
|
||
GCCReason reason
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfEjectUserRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (IsConfTopProvider())
|
||
{
|
||
if (IsThisNodeParticipant(ejected_node_id))
|
||
{
|
||
ConnectionHandle nConnHdl;
|
||
BOOL fChildNode = FALSE;
|
||
|
||
// First check to see if it is a child node that is being ejected.
|
||
m_ConnHandleList.Reset();
|
||
while (0 != (nConnHdl = m_ConnHandleList.Iterate()))
|
||
{
|
||
if (m_pMcsUserObject->GetUserIDFromConnection(nConnHdl) == ejected_node_id)
|
||
{
|
||
fChildNode = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (fChildNode ||
|
||
DoesRequesterHavePrivilege(m_pMcsUserObject->GetMyNodeID(), EJECT_USER_PRIVILEGE))
|
||
{
|
||
// Add this ejected node to the list of Ejected Nodes
|
||
m_EjectedNodeConfirmList.Append(ejected_node_id);
|
||
|
||
/*
|
||
** The user attachment object decides where the ejct should
|
||
** be sent (either to the Top Provider or conference wide as
|
||
** an indication.
|
||
*/
|
||
m_pMcsUserObject->EjectNodeFromConference(ejected_node_id, reason);
|
||
}
|
||
else
|
||
{
|
||
#ifdef JASPER
|
||
/*
|
||
** The top provider does not have the privilege to eject
|
||
** a node from the conference. Send the appropriate
|
||
** confirm.
|
||
*/
|
||
g_pControlSap->ConfEjectUserConfirm(
|
||
m_nConfID,
|
||
ejected_node_id,
|
||
GCC_RESULT_INVALID_REQUESTER);
|
||
#endif // JASPER
|
||
rc = fChildNode ? GCC_INSUFFICIENT_PRIVILEGE : GCC_INVALID_MCS_USER_ID;
|
||
WARNING_OUT(("CConf::ConfEjectUserRequest: failed, rc=%d", rc));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rc = GCC_INVALID_MCS_USER_ID;
|
||
WARNING_OUT(("CConf::ConfEjectUserRequest: failed, rc=%d", rc));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Add this ejected node to the list of Ejected Nodes
|
||
m_EjectedNodeConfirmList.Append(ejected_node_id);
|
||
|
||
/*
|
||
** The user attachment object decides where the ejct should
|
||
** be sent (either to the Top Provider or conference wide as
|
||
** an indication.
|
||
*/
|
||
m_pMcsUserObject->EjectNodeFromConference(ejected_node_id, reason);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfEjectUserRequest: conf not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfEjectUserRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
/*
|
||
* CConf::ConfAnnouncePresenceRequest ()
|
||
*
|
||
* Private Function Description
|
||
* This function forces a roster update indication and a confirm to be
|
||
* sent.
|
||
*/
|
||
GCCError CConf::
|
||
ConfAnnouncePresenceRequest ( PGCCNodeRecord node_record )
|
||
{
|
||
GCCError rc;
|
||
|
||
DebugEntry(CConf::ConfAnnouncePresenceRequest);
|
||
|
||
// If the conference is not established send back a negative confirm
|
||
if (! m_fConfIsEstablished)
|
||
{
|
||
WARNING_OUT(("CConf::ConfAnnouncePresenceRequest: conf not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** This takes care of setting up the nodes record in the
|
||
** appropriate conference roster.
|
||
*/
|
||
rc = m_pConfRosterMgr->AddNodeRecord(node_record);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
TRACE_OUT(("CConf::ConfAnnouncePresenceRequest: updating previous record"));
|
||
rc = m_pConfRosterMgr->UpdateNodeRecord(node_record);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfAnnouncePresenceRequest: can't update node record, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
// Only flush the roster data here if there is no startup alarm.
|
||
rc = AsynchFlushRosterData();
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfAnnouncePresenceRequest: can't flush roster data, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
g_pControlSap->ConfAnnouncePresenceConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::ConfAnnouncePresenceRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError ConfDisconnectRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates a disconnect of this node from the conference.
|
||
* This involves ejecting all subordinate nodes before actually
|
||
* disconnecting the parent connection.
|
||
*/
|
||
GCCError CConf::
|
||
ConfDisconnectRequest ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
UserID child_node_id;
|
||
ConnectionHandle nConnHdl;
|
||
|
||
DebugEntry(CConf::ConfDisconnectRequest);
|
||
|
||
/*
|
||
** Before we start the disconnect process we must remove all the
|
||
** outstanding invite request from our list and send back associated
|
||
** confirms. Here we go ahead disconnect all connection associated with
|
||
** the invites.
|
||
*/
|
||
DeleteOutstandingInviteRequests();
|
||
|
||
/*
|
||
** We set conference established to FALSE since the conference is
|
||
** no longer established (this also prevents a terminate indication
|
||
** from being sent).
|
||
*/
|
||
m_fConfIsEstablished = FALSE;
|
||
|
||
/*
|
||
** Iterate through the list of connection handles and eject each
|
||
** of the child nodes that is associated with it.
|
||
*/
|
||
m_ConnHandleList.Reset();
|
||
while (0 != (nConnHdl = m_ConnHandleList.Iterate()))
|
||
{
|
||
child_node_id = m_pMcsUserObject->GetUserIDFromConnection(nConnHdl);
|
||
|
||
rc = m_pMcsUserObject->EjectNodeFromConference (child_node_id,
|
||
GCC_REASON_HIGHER_NODE_DISCONNECTED);
|
||
if (rc != GCC_NO_ERROR)
|
||
{
|
||
ERROR_OUT(("CConf::ConfDisconnectRequest: can't eject node from conference"));
|
||
break;
|
||
}
|
||
}
|
||
|
||
// If there is an error we go ahead and do a hard disconnect
|
||
if (m_ConnHandleList.IsEmpty() || rc != GCC_NO_ERROR)
|
||
{
|
||
/*
|
||
** First inform the control SAP that this node has successfuly
|
||
** disconnected.
|
||
*/
|
||
rc = g_pControlSap->ConfDisconnectConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
|
||
// Tell the owner object to terminate this conference
|
||
InitiateTermination(GCC_REASON_NORMAL_TERMINATION, 0);
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Wait for all the ejects to complete before the conference is
|
||
** terminated.
|
||
*/
|
||
m_fConfDisconnectPending = TRUE;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfDisconnectRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError ConfTerminateRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This routine initiates a terminate sequence which starts with a request
|
||
* to the Top Provider if this node is not already the Top Provider.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfTerminateRequest ( GCCReason reason )
|
||
{
|
||
GCCError rc;
|
||
|
||
DebugEntry(CConf::ConfTerminateRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
/*
|
||
** Before we start the termination process we must remove all the
|
||
** outstanding invite request from our list and send back associated
|
||
** confirms. Here we go ahead disconnect all connections associated
|
||
** with these invites.
|
||
*/
|
||
DeleteOutstandingInviteRequests();
|
||
|
||
if (IsConfTopProvider())
|
||
{
|
||
if (DoesRequesterHavePrivilege( m_pMcsUserObject->GetMyNodeID(),
|
||
TERMINATE_PRIVILEGE))
|
||
{
|
||
TRACE_OUT(("CConf::ConfTerminateRequest: Node has permission to terminate"));
|
||
/*
|
||
** Since the terminate was successful, we go ahead and
|
||
** set the m_fConfIsEstablished instance variable to
|
||
** FALSE. This prevents any other messages from flowing
|
||
** to the SAPs other than terminate messages.
|
||
*/
|
||
m_fConfIsEstablished = FALSE;
|
||
|
||
// Send the terminate confirm.
|
||
g_pControlSap->ConfTerminateConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
|
||
// This call takes care of both the local and remote terminate
|
||
m_pMcsUserObject->ConferenceTerminateIndication(reason);
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::ConfTerminateRequest: Node does NOT have permission to terminate"));
|
||
g_pControlSap->ConfTerminateConfirm(m_nConfID, GCC_RESULT_INVALID_REQUESTER);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
m_pMcsUserObject->ConferenceTerminateRequest(reason);
|
||
}
|
||
rc = GCC_NO_ERROR;
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfTerminateRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfTerminateRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/********************* Registry Calls ***********************************/
|
||
|
||
|
||
/*
|
||
* GCCError RegistryRegisterChannelRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a registry request sequence. Note that the registry
|
||
* response is handled by the registry class.
|
||
*/
|
||
GCCError CConf::
|
||
RegistryRegisterChannelRequest
|
||
(
|
||
PGCCRegistryKey registry_key,
|
||
ChannelID nChnlID,
|
||
CAppSap *pAppSap
|
||
)
|
||
{
|
||
GCCError rc;
|
||
EntityID eid;
|
||
|
||
DebugEntry(CConf::RegistryRegisterChannelRequest);
|
||
|
||
rc = GetEntityIDFromAPEList(pAppSap, ®istry_key->session_key, &eid);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
rc = m_pAppRegistry->RegisterChannel(registry_key, nChnlID, eid);
|
||
}
|
||
|
||
DebugExitINT(CConf::RegistryRegisterChannelRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError RegistryAssignTokenRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a registry request sequence. Note that the registry
|
||
* response is handled by the registry class.
|
||
*/
|
||
GCCError CConf::
|
||
RegistryAssignTokenRequest
|
||
(
|
||
PGCCRegistryKey registry_key,
|
||
CAppSap *pAppSap
|
||
)
|
||
{
|
||
GCCError rc;
|
||
GCCEntityID eid;
|
||
|
||
DebugEntry(CConf::RegistryAssignTokenRequest);
|
||
|
||
rc = GetEntityIDFromAPEList(pAppSap, ®istry_key->session_key, &eid);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
rc = m_pAppRegistry->AssignToken(registry_key, eid);
|
||
}
|
||
|
||
DebugExitINT(CConf::RegistryAssignTokenRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError RegistrySetParameterRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a registry request sequence. Note that the registry
|
||
* response is handled by the registry class.
|
||
*/
|
||
GCCError CConf::
|
||
RegistrySetParameterRequest
|
||
(
|
||
PGCCRegistryKey registry_key,
|
||
LPOSTR parameter_value,
|
||
GCCModificationRights modification_rights,
|
||
CAppSap *pAppSap
|
||
)
|
||
{
|
||
GCCError rc;
|
||
GCCEntityID eid;
|
||
|
||
DebugEntry(CConf::RegistrySetParameterRequest);
|
||
|
||
rc = GetEntityIDFromAPEList(pAppSap, ®istry_key->session_key, &eid);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
rc = m_pAppRegistry->SetParameter(registry_key,
|
||
parameter_value,
|
||
modification_rights,
|
||
eid);
|
||
}
|
||
|
||
DebugExitINT(CConf::RegistrySetParameterRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError RegistryRetrieveEntryRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a registry request sequence. Note that the registry
|
||
* response is handled by the registry class.
|
||
*/
|
||
GCCError CConf::
|
||
RegistryRetrieveEntryRequest
|
||
(
|
||
PGCCRegistryKey registry_key,
|
||
CAppSap *pAppSap
|
||
)
|
||
{
|
||
GCCError rc;
|
||
GCCEntityID eid;
|
||
|
||
DebugEntry(CConf::RegistryRetrieveEntryRequest);
|
||
|
||
rc = GetEntityIDFromAPEList(pAppSap, ®istry_key->session_key, &eid);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
rc = m_pAppRegistry->RetrieveEntry(registry_key, eid);
|
||
}
|
||
|
||
DebugExitINT(CConf::RegistryRetrieveEntryRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError RegistryDeleteEntryRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a registry request sequence. Note that the registry
|
||
* response is handled by the registry class.
|
||
*/
|
||
GCCError CConf::
|
||
RegistryDeleteEntryRequest
|
||
(
|
||
PGCCRegistryKey registry_key,
|
||
CAppSap *pAppSap
|
||
)
|
||
{
|
||
GCCError rc;
|
||
EntityID eid;
|
||
|
||
DebugEntry(CConf::RegistryDeleteEntryRequest);
|
||
|
||
rc = GetEntityIDFromAPEList(pAppSap, ®istry_key->session_key, &eid);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
rc = m_pAppRegistry->DeleteEntry(registry_key, eid);
|
||
}
|
||
|
||
DebugExitINT(CConf::RegistryDeleteEntryRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError RegistryMonitorRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a registry request sequence. Note that the registry
|
||
* response is handled by the registry class.
|
||
*/
|
||
GCCError CConf::
|
||
RegistryMonitorRequest
|
||
(
|
||
BOOL fEnableDelivery,
|
||
PGCCRegistryKey registry_key,
|
||
CAppSap *pAppSap)
|
||
{
|
||
GCCError rc;
|
||
GCCEntityID eid;
|
||
|
||
DebugEntry(CConf::RegistryMonitorRequest);
|
||
|
||
rc = GetEntityIDFromAPEList(pAppSap, ®istry_key->session_key, &eid);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
rc = m_pAppRegistry->MonitorRequest(registry_key, fEnableDelivery, eid);
|
||
}
|
||
|
||
DebugExitINT(CConf:RegistryMonitorRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError RegistryAllocateHandleRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a registry request sequence. Note that the registry
|
||
* response is handled by the registry class. This registry call is
|
||
* a bit different from the other registry calls. Notice that there is
|
||
* no registry key associated with this call so there is no way to
|
||
* explicitly determine the entity ID. Luckily, the entity ID is not
|
||
* passed back in the allocate confirm so we just pick an entity id
|
||
* that is associated with this SAP. It makes no difference which one
|
||
* we pick because they all accomplish the same thing.
|
||
*/
|
||
GCCError CConf::
|
||
RegistryAllocateHandleRequest
|
||
(
|
||
UINT cHandles,
|
||
CAppSap *pAppSap
|
||
)
|
||
{
|
||
GCCError rc;
|
||
ENROLLED_APE_INFO *lpEnrAPEInfo;
|
||
GCCEntityID eid;
|
||
|
||
DebugEntry(CConf::RegistryAllocateHandleRequest);
|
||
|
||
// First we must find a single entity id that is associated with this SAP.
|
||
if (NULL != (lpEnrAPEInfo = GetEnrolledAPEbySap(pAppSap, &eid)))
|
||
{
|
||
ASSERT(GCC_INVALID_EID != eid);
|
||
rc = m_pAppRegistry->AllocateHandleRequest(cHandles, eid);
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::RegistryAllocateHandleRequest: Application not enrolled"));
|
||
rc = GCC_APP_NOT_ENROLLED;
|
||
}
|
||
|
||
DebugExitINT(CConf::RegistryAllocateHandleRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/********************* Conductorship Calls ***********************************/
|
||
|
||
|
||
/*
|
||
* GCCError ConductorAssignRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This initiates a Conductor assign request sequence. Here the node is
|
||
* requesting to become the conductor.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConductorAssignRequest ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCResult eResult = INVALID_GCC_RESULT;
|
||
|
||
DebugEntry(CConf::ConductorAssignRequest);
|
||
|
||
// Return an error if the conference is not established.
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (m_fConfConductible)
|
||
{
|
||
if (m_nConductorNodeID != m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
if ((m_nPendingConductorNodeID == 0) && ! m_fConductorGiveResponsePending)
|
||
{
|
||
m_fConductorAssignRequestPending = TRUE;
|
||
rc = m_pMcsUserObject->ConductorTokenGrab();
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::ConductorAssignConfirm:Give Pending"));
|
||
eResult = GCC_RESULT_CONDUCTOR_GIVE_IS_PENDING;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorAssignRequest: Already Conductor"));
|
||
/*
|
||
** Since we are already the conductor send back a successful
|
||
** result
|
||
*/
|
||
//
|
||
// LONCHANC: Why not GCC_RESULT_ALREADY_CONDUCTOR?
|
||
//
|
||
eResult = GCC_RESULT_SUCCESSFUL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorAssignRequest: not conductible"));
|
||
eResult = GCC_RESULT_NOT_CONDUCTIBLE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorAssignRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (INVALID_GCC_RESULT != eResult)
|
||
{
|
||
g_pControlSap->ConductorAssignConfirm(eResult, m_nConfID);
|
||
}
|
||
#endif // JASPER
|
||
|
||
DebugExitINT(CConf::ConductorAssignRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConductorReleaseRequest ()
|
||
*
|
||
* Public Function Description
|
||
* Here the node is attempting to give up conductorship.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConductorReleaseRequest ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCResult eResult = INVALID_GCC_RESULT;
|
||
|
||
DebugEntry(CConf::ConductorReleaseRequest);
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
if (m_nConductorNodeID == m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
if (m_nPendingConductorNodeID == 0)
|
||
{
|
||
/*
|
||
** This does not seem right, but this is the way that T.124
|
||
** defines it should work.
|
||
*/
|
||
m_nConductorNodeID = 0; // Set back to non-conducted mode
|
||
|
||
m_fConductorGrantedPermission = FALSE;
|
||
|
||
rc = m_pMcsUserObject->SendConductorReleaseIndication();
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
rc = m_pMcsUserObject->ConductorTokenRelease();
|
||
|
||
/*
|
||
** Inform the control SAP and all the enrolled application
|
||
** SAPs that the conductor was released. We do this here
|
||
** because we will not process the release indication
|
||
** when it comes back in.
|
||
*/
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
g_pControlSap->ConductorReleaseIndication(m_nConfID);
|
||
|
||
/*
|
||
** We iterate on a temporary list to avoid any problems
|
||
** if the application sap leaves during the callback.
|
||
*/
|
||
CAppSap *pAppSap;
|
||
CAppSapList TempList(m_RegisteredAppSapList);
|
||
TempList.Reset();
|
||
while (NULL != (pAppSap = TempList.Iterate()))
|
||
{
|
||
if (DoesSAPHaveEnrolledAPE(pAppSap))
|
||
{
|
||
pAppSap->ConductorReleaseIndication(m_nConfID);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf: ConductorReleaseRequest: Give Pending"));
|
||
eResult = GCC_RESULT_CONDUCTOR_GIVE_IS_PENDING;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorReleaseRequest: Not the Conductor"));
|
||
eResult = GCC_RESULT_NOT_THE_CONDUCTOR;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorReleaseRequest: not conductible"));
|
||
eResult = GCC_RESULT_NOT_CONDUCTIBLE;
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (INVALID_GCC_RESULT != eResult)
|
||
{
|
||
g_pControlSap->ConductorReleaseConfirm(eResult, m_nConfID);
|
||
}
|
||
#endif // JASPER
|
||
|
||
DebugExitINT(CConf::ConductorReleaseRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConductorPleaseRequest ()
|
||
*
|
||
* Public Function Description
|
||
* Here the node is asking to be given conductorship.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConductorPleaseRequest ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCResult eResult = INVALID_GCC_RESULT;
|
||
|
||
DebugEntry(CConf::ConductorPleaseRequest);
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
// Return an error if the conference is not established
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
if (m_nConductorNodeID != m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
rc = m_pMcsUserObject->ConductorTokenPlease();
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
// Send back positive confirm if successful
|
||
eResult = GCC_RESULT_SUCCESSFUL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::ConductorPleaseRequest: already conductor"));
|
||
eResult = GCC_RESULT_ALREADY_CONDUCTOR;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorPleaseRequest: not in conducted mode"));
|
||
eResult = GCC_RESULT_NOT_IN_CONDUCTED_MODE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorPleaseRequest: not conductible"));
|
||
eResult = GCC_RESULT_NOT_CONDUCTIBLE;
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (INVALID_GCC_RESULT != eResult)
|
||
{
|
||
g_pControlSap->ConductorPleaseConfirm(eResult, m_nConfID);
|
||
}
|
||
#endif // JASPER
|
||
|
||
DebugExitINT(CConf::ConductorPleaseRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConductorGiveRequest ()
|
||
*
|
||
* Public Function Description
|
||
* The function is called when the conductor wants to pass off
|
||
* conductorship to a different node.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConductorGiveRequest ( UserID recipient_node_id )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCResult eResult = INVALID_GCC_RESULT;
|
||
|
||
DebugEntry(CConf::ConductorGiveRequest);
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
// Am I in conducted mode?
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
// Am I the conductor?
|
||
if (m_nConductorNodeID == m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
if (recipient_node_id != m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
if (m_nPendingConductorNodeID == 0)
|
||
{
|
||
/*
|
||
** We don't assume that the recipient node is the new
|
||
** conductor until we get a confirm or an
|
||
** AssignIndication. The m_nPendingConductorNodeID is
|
||
** used to buffer the recipient until the give confirm
|
||
** is received.
|
||
*/
|
||
m_nPendingConductorNodeID = recipient_node_id;
|
||
rc = m_pMcsUserObject->ConductorTokenGive(recipient_node_id);
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::ConductorGiveRequest: conductor give is pending"));
|
||
eResult = GCC_RESULT_CONDUCTOR_GIVE_IS_PENDING;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::ConductorGiveRequest: already conductor"));
|
||
eResult = GCC_RESULT_ALREADY_CONDUCTOR;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorGiveRequest: not the conductor"));
|
||
eResult = GCC_RESULT_NOT_THE_CONDUCTOR;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorGiveRequest: not in conduct mode"));
|
||
eResult = GCC_RESULT_NOT_IN_CONDUCTED_MODE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorGiveRequest: not conductible"));
|
||
eResult = GCC_RESULT_NOT_CONDUCTIBLE;
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (INVALID_GCC_RESULT != eResult)
|
||
{
|
||
g_pControlSap->ConductorGiveConfirm(eResult, m_nConfID, recipient_node_id);
|
||
}
|
||
#endif // JASPER
|
||
|
||
DebugExitINT(CConf::ConductorGiveRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConductorGiveResponse ()
|
||
*
|
||
* Public Function Description
|
||
* This function gets called in response to a Conductor Give Indication.
|
||
* If result is success then this node is the new conductor.
|
||
*/
|
||
GCCError CConf::
|
||
ConductorGiveResponse ( GCCResult eResult )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConductorGiveResponse);
|
||
|
||
if (! m_fConductorGiveResponsePending)
|
||
{
|
||
ERROR_OUT(("CConf::ConductorGiveResponse: no give response pending"));
|
||
rc = GCC_NO_GIVE_RESPONSE_PENDING;
|
||
goto MyExit;
|
||
}
|
||
|
||
m_fConductorGiveResponsePending = FALSE;
|
||
|
||
if (eResult == GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
// Set the conductor id to my user id if the response is success.
|
||
m_nConductorNodeID = m_pMcsUserObject->GetMyNodeID();
|
||
|
||
// The new conductor always has permission.
|
||
m_fConductorGrantedPermission = TRUE;
|
||
|
||
/*
|
||
** We must perform the give response before sending the dummy to
|
||
** the top provider so that MCS knows that the conductor token
|
||
** belongs to this node.
|
||
*/
|
||
rc = m_pMcsUserObject->ConductorTokenGiveResponse(RESULT_SUCCESSFUL);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConductorGiveResponse: ConductorTokenGiveResponse failed, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** If this node is not the Top Provider, we must try to Give the
|
||
** Conductor token to the Top Provider. The Top Provider is used
|
||
** to issue the Assign Indication whenever the conductor changes
|
||
** hands.
|
||
*/
|
||
if (m_pMcsUserObject->GetMyNodeID() != m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
rc = m_pMcsUserObject->ConductorTokenGive(m_pMcsUserObject->GetTopNodeID());
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Here we go ahead and send the assign indication because we
|
||
** are already at the Top Provider.
|
||
*/
|
||
rc = m_pMcsUserObject->SendConductorAssignIndication(m_nConductorNodeID);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Inform that giver that we are not interested
|
||
rc = m_pMcsUserObject->ConductorTokenGiveResponse(RESULT_USER_REJECTED);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::ConductorGiveResponse, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError ConductorPermitAskRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This call is made when a node wants to request permission from the
|
||
* conductor.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConductorPermitAskRequest ( BOOL grant_permission )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCResult eResult = INVALID_GCC_RESULT;
|
||
|
||
DebugEntry(CConf::ConductorPermitAskRequest);
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
// Am I in conducted mode?
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
if (m_nConductorNodeID != m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
rc = m_pMcsUserObject->SendConductorPermitAsk(grant_permission);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
eResult = GCC_RESULT_SUCCESSFUL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::ConductorPermitAskRequest: already conductor"));
|
||
eResult = GCC_RESULT_ALREADY_CONDUCTOR;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorPermitAskRequest: not in conducted mode"));
|
||
eResult = GCC_RESULT_NOT_IN_CONDUCTED_MODE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorPermitAskRequest: not conductible"));
|
||
eResult = GCC_RESULT_NOT_CONDUCTIBLE;
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (INVALID_GCC_RESULT != eResult)
|
||
{
|
||
g_pControlSap->ConductorPermitAskConfirm(eResult, grant_permission, m_nConfID);
|
||
}
|
||
#endif // JASPER
|
||
|
||
DebugExitINT(CConf::ConductorPermitAskRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConductorPermitGrantRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function is called when a conductor wishes to grant permission
|
||
* to a specific node or to a list of nodes.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConductorPermitGrantRequest
|
||
(
|
||
UINT number_granted,
|
||
PUserID granted_node_list,
|
||
UINT number_waiting,
|
||
PUserID waiting_node_list
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCResult eResult = INVALID_GCC_RESULT;
|
||
|
||
DebugEntry(CConf::ConductorPermitGrantRequest);
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
// Am I in conducted mode?
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
// Am I the conductor?
|
||
if (m_nConductorNodeID == m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
TRACE_OUT(("CConf: ConductorPermitGrantRequest: SEND: number_granted = %d", number_granted));
|
||
|
||
rc = m_pMcsUserObject->SendConductorPermitGrant(
|
||
number_granted,
|
||
granted_node_list,
|
||
number_waiting,
|
||
waiting_node_list);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
eResult = GCC_RESULT_SUCCESSFUL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorPermitGrantRequest: not the conductor"));
|
||
eResult = GCC_RESULT_NOT_THE_CONDUCTOR;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorPermitGrantRequest: not in conducted mode"));
|
||
eResult = GCC_RESULT_NOT_IN_CONDUCTED_MODE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorPermitGrantRequest: not conductible"));
|
||
eResult = GCC_RESULT_NOT_CONDUCTIBLE;
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (INVALID_GCC_RESULT != eResult)
|
||
{
|
||
g_pControlSap->ConductorPermitGrantConfirm(eResult, m_nConfID);
|
||
}
|
||
#endif // JASPER
|
||
|
||
DebugExitINT(CConf::ConductorPermitGrantRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConductorInquireRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function is called when a node request conductorship information.
|
||
*/
|
||
GCCError CConf::
|
||
ConductorInquireRequest ( CBaseSap *pSap )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCResult eResult = INVALID_GCC_RESULT;
|
||
|
||
DebugEntry(CConf::ConductorInquireRequest);
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
rc = m_pMcsUserObject->ConductorTokenTest();
|
||
|
||
/*
|
||
** We must "push" the command target to the to the list of
|
||
** outstanding conductor test request. When the test confirm
|
||
** comes back the command target will be "poped" of the list.
|
||
** Note that all test request must be processed in the order that
|
||
** they are requested.
|
||
*/
|
||
m_ConductorTestList.Append(pSap);
|
||
}
|
||
else
|
||
{
|
||
// If not in conducted mode send back NO conductor information
|
||
ERROR_OUT(("CConf::ConductorInquireRequest: not in conducted mode"));
|
||
eResult = GCC_RESULT_NOT_IN_CONDUCTED_MODE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConductorInquireRequest: not conductible"));
|
||
eResult = GCC_RESULT_NOT_CONDUCTIBLE;
|
||
}
|
||
|
||
if (INVALID_GCC_RESULT != eResult)
|
||
{
|
||
pSap->ConductorInquireConfirm(NULL,
|
||
eResult,
|
||
m_fConductorGrantedPermission,
|
||
FALSE,
|
||
m_nConfID);
|
||
}
|
||
|
||
DebugExitINT(CConf:ConductorInquireRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
/********************** Miscelaneous Finctions **********************/
|
||
|
||
|
||
/*
|
||
* GCCError ConferenceTimeRemainingRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates a TimeRemainingRequest sequence.
|
||
*/
|
||
GCCError CConf::
|
||
ConferenceTimeRemainingRequest
|
||
(
|
||
UINT time_remaining,
|
||
UserID node_id
|
||
)
|
||
{
|
||
GCCError rc;
|
||
|
||
DebugEntry(CConf::ConferenceTimeRemainingRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
rc = m_pMcsUserObject->TimeRemainingRequest(time_remaining, node_id);
|
||
#ifdef JASPER
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
g_pControlSap->ConfTimeRemainingConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
}
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConferenceTimeRemainingRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConferenceTimeRemainingRequest, rc);
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError ConfTimeInquireRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates a ConfTimeInquireRequest sequence.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfTimeInquireRequest ( BOOL time_is_conference_wide )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfTimeInquireRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if ((m_eNodeType == CONVENER_NODE) ||
|
||
(m_eNodeType == TOP_PROVIDER_AND_CONVENER_NODE)||
|
||
(m_eNodeType == JOINED_CONVENER_NODE))
|
||
{
|
||
g_pControlSap->ConfTimeInquireIndication(
|
||
m_nConfID,
|
||
time_is_conference_wide,
|
||
m_pMcsUserObject->GetMyNodeID());
|
||
}
|
||
else
|
||
{
|
||
rc = m_pMcsUserObject->TimeInquireRequest(time_is_conference_wide);
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
g_pControlSap->ConfTimeInquireConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
}
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfTimeInquireRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfTimeInquireRequest, rc);
|
||
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConfExtendRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates a ConfExtendRequest sequence.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfExtendRequest
|
||
(
|
||
UINT extension_time,
|
||
BOOL time_is_conference_wide
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfExtendRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if ((m_eNodeType == CONVENER_NODE) ||
|
||
(m_eNodeType == TOP_PROVIDER_AND_CONVENER_NODE)||
|
||
(m_eNodeType == JOINED_CONVENER_NODE))
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfExtendIndication(
|
||
m_nConfID,
|
||
extension_time,
|
||
time_is_conference_wide,
|
||
m_pMcsUserObject->GetMyNodeID());
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
rc = m_pMcsUserObject->ConferenceExtendIndication(
|
||
extension_time,
|
||
time_is_conference_wide);
|
||
}
|
||
|
||
#ifdef JASPER
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
g_pControlSap->ConfExtendConfirm(
|
||
m_nConfID,
|
||
extension_time,
|
||
GCC_RESULT_SUCCESSFUL);
|
||
}
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfExtendRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfExtendRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConfAssistanceRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates a ConfAssistanceRequest sequence.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfAssistanceRequest
|
||
(
|
||
UINT number_of_user_data_members,
|
||
PGCCUserData *user_data_list
|
||
)
|
||
{
|
||
GCCError rc;
|
||
|
||
DebugEntry(CConf::ConfAssistanceRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
rc = m_pMcsUserObject->ConferenceAssistanceIndication(
|
||
number_of_user_data_members,
|
||
user_data_list);
|
||
#ifdef JASPER
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
g_pControlSap->ConfAssistanceConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
}
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfAssistanceRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfAssistanceRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
/*
|
||
* GCCError AppInvokeRequest()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates an ApplicationInvokeRequest sequence.
|
||
*/
|
||
GCCError CConf::
|
||
AppInvokeRequest
|
||
(
|
||
CInvokeSpecifierListContainer *invoke_list,
|
||
GCCSimpleNodeList *pNodeList,
|
||
CBaseSap *pSap,
|
||
GCCRequestTag nReqTag
|
||
)
|
||
{
|
||
GCCError rc;
|
||
|
||
DebugEntry(CConf::AppInvokeRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
rc = m_pMcsUserObject->AppInvokeIndication(invoke_list, pNodeList);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
pSap->AppInvokeConfirm(m_nConfID, invoke_list, GCC_RESULT_SUCCESSFUL, nReqTag);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::AppInvokeRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::AppInvokeRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError TextMessageRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates an TextMessageRequest sequence.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
TextMessageRequest
|
||
(
|
||
LPWSTR pwszTextMsg,
|
||
UserID destination_node
|
||
)
|
||
{
|
||
GCCError rc;
|
||
|
||
DebugEntry(CConf::TextMessageRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (destination_node != m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
rc = m_pMcsUserObject->TextMessageIndication(pwszTextMsg, destination_node);
|
||
#ifdef JASPER
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
g_pControlSap->TextMessageConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
}
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::TextMessageRequest: invalid user ID"));
|
||
rc = GCC_INVALID_MCS_USER_ID;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::TextMessageRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::TextMessageRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConfTransferRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates an ConfTransferRequest sequence.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfTransferRequest
|
||
(
|
||
PGCCConferenceName destination_conference_name,
|
||
GCCNumericString destination_conference_modifier,
|
||
CNetAddrListContainer *destination_address_list,
|
||
UINT number_of_destination_nodes,
|
||
PUserID destination_node_list,
|
||
CPassword *password
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ConfTransferRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (IsConfTopProvider())
|
||
{
|
||
if (DoesRequesterHavePrivilege( m_pMcsUserObject->GetMyNodeID(),
|
||
TRANSFER_PRIVILEGE))
|
||
{
|
||
rc = m_pMcsUserObject->ConferenceTransferIndication(
|
||
destination_conference_name,
|
||
destination_conference_modifier,
|
||
destination_address_list,
|
||
number_of_destination_nodes,
|
||
destination_node_list,
|
||
password);
|
||
#ifdef JASPER
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
g_pControlSap->ConfTransferConfirm(
|
||
m_nConfID,
|
||
destination_conference_name,
|
||
destination_conference_modifier,
|
||
number_of_destination_nodes,
|
||
destination_node_list,
|
||
GCC_RESULT_SUCCESSFUL);
|
||
}
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::ConfTransferRequest: insufficient privilege to transfer conference"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rc = m_pMcsUserObject->ConferenceTransferRequest(
|
||
destination_conference_name,
|
||
destination_conference_modifier,
|
||
destination_address_list,
|
||
number_of_destination_nodes,
|
||
destination_node_list,
|
||
password);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfTransferRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfTransferRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConfAddRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This function initiates an ConfAddRequest sequence.
|
||
*/
|
||
#ifdef JASPER
|
||
GCCError CConf::
|
||
ConfAddRequest
|
||
(
|
||
CNetAddrListContainer *network_address_container,
|
||
UserID adding_node,
|
||
CUserDataListContainer *user_data_container
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
TagNumber conference_add_tag;
|
||
UserID target_node;
|
||
|
||
DebugEntry(CConf::ConfAddRequest);
|
||
|
||
if (! m_fConfIsEstablished)
|
||
{
|
||
ERROR_OUT(("CConf::ConfAddRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** A node cannot tell itself to add because of the way the
|
||
** Add Response call works. Since an Add Response is sent non-
|
||
** uniformly directly to the node that made the request the response
|
||
** would never reach the requesting node. Therefore, this is flaged
|
||
** as an error condition here.
|
||
*/
|
||
if (adding_node == m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
ERROR_OUT(("CConf::ConfAddRequest: can't tell myself to add"));
|
||
rc = GCC_BAD_ADDING_NODE;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** Note that the way the standard reads, it looks like you
|
||
** do not have to check the privileges for the top provider
|
||
** on an Add. We do though check to see if the Top Provider is
|
||
** making the request to a node other than the top provider. If
|
||
** not this is considered an error here.
|
||
*/
|
||
if (IsConfTopProvider())
|
||
{
|
||
/*
|
||
** If the adding node is zero at the top provider, this is
|
||
** the same as specifying ones self to be the adding node.
|
||
*/
|
||
if (adding_node == 0)
|
||
{
|
||
ERROR_OUT(("CConf::ConfAddRequest: can't tell myself to add"));
|
||
rc = GCC_BAD_ADDING_NODE;
|
||
goto MyExit;
|
||
}
|
||
else
|
||
{
|
||
target_node = adding_node;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
target_node = m_pMcsUserObject->GetTopNodeID();
|
||
}
|
||
|
||
// First determine the conference add tag
|
||
while (1)
|
||
{
|
||
conference_add_tag = ++m_nConfAddRequestTagNumber;
|
||
if (NULL == m_AddRequestList.Find(conference_add_tag))
|
||
break;
|
||
}
|
||
|
||
// Send out the PDU
|
||
rc = m_pMcsUserObject->ConferenceAddRequest(
|
||
conference_add_tag,
|
||
m_pMcsUserObject->GetMyNodeID(),
|
||
adding_node,
|
||
target_node,
|
||
network_address_container,
|
||
user_data_container);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfAddRequest: ConferenceAddRequest failed, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** We must lock the network address to keep it from
|
||
** being deleted upon returning.
|
||
*/
|
||
if (network_address_container != NULL)
|
||
{
|
||
network_address_container->LockNetworkAddressList();
|
||
}
|
||
|
||
// Add this entry to the add request list.
|
||
m_AddRequestList.Append(conference_add_tag, network_address_container);
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::ConfAddRequest, rc);
|
||
return rc;
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
/*
|
||
* GCCError ConfAddResponse ()
|
||
*
|
||
* Public Function Description
|
||
* This call is made in response to an Add indication. It is initiated
|
||
* by the Node Controller.
|
||
*/
|
||
GCCError CConf::
|
||
ConfAddResponse
|
||
(
|
||
GCCResponseTag add_response_tag,
|
||
UserID requesting_node,
|
||
CUserDataListContainer *user_data_container,
|
||
GCCResult result
|
||
)
|
||
{
|
||
GCCError rc;
|
||
TagNumber lTagNum;
|
||
|
||
DebugEntry(CConf::ConfAddResponse);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
if (0 != (lTagNum = m_AddResponseList.Find(add_response_tag)))
|
||
{
|
||
// Send out the response PDU
|
||
rc = m_pMcsUserObject->ConferenceAddResponse(lTagNum, requesting_node,
|
||
user_data_container, result);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
m_AddResponseList.Remove(add_response_tag);
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfAddResponse: ConferenceAddResponse failed, rc=%d", rc));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfAddResponse: invalid add response tag"));
|
||
rc = GCC_INVALID_ADD_RESPONSE_TAG;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfAddResponse: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfAddResponse, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
** These calls are received from the User Attachment object via the
|
||
** Owner-Callback routine. Note that all calls received from the
|
||
** user attachment object are preceeded by the word Process.
|
||
*/
|
||
|
||
|
||
/*
|
||
* CConf::ProcessRosterUpdateIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine is responsible for processing all the incomming roster
|
||
* update PDUs which are received from subordinate nodes. These
|
||
* roster updates typically only include additions, changes or deletions
|
||
* of a few records within each PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* roster_update - This is the PDU structure that contains the data
|
||
* associated with the roster update.
|
||
* sender_id - User ID of node that sent the roster update.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessRosterUpdatePDU
|
||
(
|
||
PGCCPDU roster_update,
|
||
UserID sender_id
|
||
)
|
||
{
|
||
GCCError err = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::ProcessRosterUpdatePDU);
|
||
|
||
if (m_pConfRosterMgr != NULL)
|
||
{
|
||
err = m_pConfRosterMgr->RosterUpdateIndication(roster_update, sender_id);
|
||
if (err != GCC_NO_ERROR)
|
||
{
|
||
goto MyExit;
|
||
}
|
||
|
||
// Process the whole PDU before performing the flush.
|
||
err = ProcessAppRosterIndicationPDU(roster_update, sender_id);
|
||
if (err != GCC_NO_ERROR)
|
||
{
|
||
goto MyExit;
|
||
}
|
||
|
||
UpdateNodeVersionList(roster_update, sender_id);
|
||
|
||
/*
|
||
** If this is the top provider and we are adding new nodes
|
||
** then we must update the new node with various roster
|
||
** information. That is what is going on here. If no new
|
||
** nodes have been added we go ahead and perform the
|
||
** Flush here.
|
||
*/
|
||
if (IsConfTopProvider() &&
|
||
roster_update->u.indication.u.roster_update_indication.node_information.nodes_are_added)
|
||
{
|
||
err = UpdateNewConferenceNode ();
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// We just got an roster update from the wire.
|
||
//
|
||
err = FlushRosterData();
|
||
}
|
||
}
|
||
|
||
MyExit:
|
||
|
||
if (err != GCC_NO_ERROR)
|
||
{
|
||
ERROR_OUT(("CConf::ProcessRosterUpdatePDU: error processing roster refresh indication"));
|
||
InitiateTermination(GCC_REASON_ERROR_TERMINATION, 0);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessRosterUpdatePDU);
|
||
}
|
||
|
||
/*
|
||
* GCCError ProcessAppRosterIndicationPDU ()
|
||
*
|
||
* Private Function Description
|
||
* This function operates specifically on the application roster
|
||
* portion of a roster PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* roster_update - This is the PDU structure that contains the data
|
||
* associated with the roster update.
|
||
* sender_id - User ID of node that sent the roster update.
|
||
*
|
||
* Return Value
|
||
* GCC_NO_ERROR - No error.
|
||
* GCC_ALLOCATION_FAILURE - A resource error occured.
|
||
* GCC_BAD_SESSION_KEY - A bad session key exists in the update.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
GCCError CConf::
|
||
ProcessAppRosterIndicationPDU
|
||
(
|
||
PGCCPDU roster_update,
|
||
UserID sender_id
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
PSetOfApplicationInformation set_of_application_info;
|
||
CAppRosterMgr *app_roster_manager;
|
||
CAppRosterMgr *new_app_roster_manager;
|
||
PSessionKey session_key;
|
||
|
||
DebugEntry(CConf::ProcessAppRosterIndicationPDU);
|
||
|
||
set_of_application_info = roster_update->u.indication.u.
|
||
roster_update_indication.application_information;
|
||
|
||
/*
|
||
** First we iterate through the complete set of application information
|
||
** to determine if there is information here for an application roster
|
||
** manager that does not yet exists. If we find one that does not
|
||
** exists we must go ahead and create it.
|
||
*/
|
||
while (set_of_application_info != NULL)
|
||
{
|
||
CAppRosterMgr *pMgr;
|
||
|
||
// First set up the session key PDU pointer
|
||
session_key = &set_of_application_info->value.session_key;
|
||
|
||
/*
|
||
** We first iterate through the complete list of application
|
||
** roster manager objects looking for one with an application key that
|
||
** matches the key in the PDU. If it is not found we create it.
|
||
*/
|
||
app_roster_manager = NULL;
|
||
new_app_roster_manager = NULL;
|
||
|
||
//
|
||
// LONCHANC: We should be able to move this as separate common subroutine.
|
||
//
|
||
m_AppRosterMgrList.Reset();
|
||
while (NULL != (pMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
if (pMgr->IsThisYourSessionKeyPDU(session_key))
|
||
{
|
||
// This application roster manager exist so return it.
|
||
app_roster_manager = pMgr;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
** If a roster manager associated with this app key does not exist
|
||
** we must create it here.
|
||
*/
|
||
if (app_roster_manager == NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
app_roster_manager = new CAppRosterMgr(
|
||
NULL,
|
||
session_key,
|
||
m_nConfID,
|
||
m_pMcsUserObject,
|
||
this,
|
||
&rc);
|
||
if (NULL == app_roster_manager || GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ProcessAppRosterIndicationPDU: can't create app roster mgr, rc=%d", rc));
|
||
if (NULL != app_roster_manager)
|
||
{
|
||
app_roster_manager->Release();
|
||
}
|
||
else
|
||
{
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
goto MyExit;
|
||
}
|
||
|
||
new_app_roster_manager = app_roster_manager;
|
||
}
|
||
|
||
/*
|
||
** We no process this set of application information. We pass it
|
||
** to the app roster manager found or created above.
|
||
*/
|
||
rc = app_roster_manager->ProcessRosterUpdateIndicationPDU(
|
||
set_of_application_info,
|
||
sender_id);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
//
|
||
// LONCHANC: We should delete the newly created roster mgr.
|
||
//
|
||
if (NULL != new_app_roster_manager)
|
||
{
|
||
new_app_roster_manager->Release();
|
||
}
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** Save the new application roster manager if one was created
|
||
** when processing this roster update.
|
||
*/
|
||
if (new_app_roster_manager != NULL)
|
||
{
|
||
m_AppRosterMgrList.Append(new_app_roster_manager);
|
||
}
|
||
|
||
// Load the next application information structure.
|
||
set_of_application_info = set_of_application_info->next;
|
||
}
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::ProcessAppRosterIndicationPDU, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessDetachUserIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine sends the detach user indication to the node controler
|
||
* and updates the roster.
|
||
*
|
||
* Formal Parameters:
|
||
* detached_user - User ID of user that detached from the conference.
|
||
* reason - Reason that the user detached.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessDetachUserIndication
|
||
(
|
||
UserID detached_user,
|
||
GCCReason reason
|
||
)
|
||
{
|
||
GCCError err = GCC_NO_ERROR;
|
||
UINT cRecords;
|
||
|
||
DebugEntry(CConf::ProcessDetachUserIndication);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
CAppRosterMgr *lpAppRosterMgr;
|
||
/*
|
||
** Send a disconnect indication to the node controller if this
|
||
** detached user corresponds to a GCC user id.
|
||
*/
|
||
if (m_pConfRosterMgr->Contains(detached_user))
|
||
{
|
||
g_pControlSap->ConfDisconnectIndication(
|
||
m_nConfID,
|
||
reason,
|
||
detached_user);
|
||
}
|
||
|
||
// Here we update the CConf Roster and the Application Roster.
|
||
err = m_pConfRosterMgr->RemoveUserReference(detached_user);
|
||
if (err == GCC_NO_ERROR)
|
||
{
|
||
if (IsConfTopProvider())
|
||
{
|
||
cRecords = m_pConfRosterMgr->GetNumberOfNodeRecords();
|
||
/*
|
||
** If only one record remains in the conference roster
|
||
** it must be the local nodes record. Therefore, if
|
||
** the conference is set up to be automatically
|
||
** terminated the owner object is notified to delete
|
||
** the conference.
|
||
*/
|
||
if ((m_eTerminationMethod == GCC_AUTOMATIC_TERMINATION_METHOD)
|
||
&& (cRecords == 1))
|
||
{
|
||
TRACE_OUT(("CConf::ProcessDetachUserIndication: AUTOMATIC_TERMINATION"));
|
||
InitiateTermination(GCC_REASON_NORMAL_TERMINATION, 0);
|
||
}
|
||
|
||
// If this is the convener set its node id back to 0
|
||
if (m_nConvenerNodeID == detached_user)
|
||
{
|
||
m_nConvenerNodeID = 0;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
if (err == GCC_INVALID_PARAMETER)
|
||
{
|
||
err = GCC_NO_ERROR;
|
||
}
|
||
|
||
/*
|
||
** Cleanup the Application Rosters of any records owned by this node.
|
||
*/
|
||
m_AppRosterMgrList.Reset();
|
||
while (NULL != (lpAppRosterMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
err = lpAppRosterMgr->RemoveUserReference(detached_user);
|
||
if (GCC_NO_ERROR != err)
|
||
{
|
||
WARNING_OUT(("CConf::ProcessDetachUserIndication: can't remove user reference from app roster mgr, err=%d", err));
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Remove ownership rights this user had on any registry entries.
|
||
m_pAppRegistry->RemoveNodeOwnership(detached_user);
|
||
|
||
// Cleanup Conductorship if detached user was the conductor
|
||
if (detached_user == m_nConductorNodeID)
|
||
{
|
||
ProcessConductorReleaseIndication(0);
|
||
}
|
||
|
||
/*
|
||
** Here we give the roster managers a chance to flush any PDUs
|
||
** or data that might have gotten queued when removing the user
|
||
** reference. An error here is considered FATAL in that the conference
|
||
** information base at this node is now corrupted therefore we
|
||
** terminate the conference.
|
||
*/
|
||
if (err == GCC_NO_ERROR)
|
||
{
|
||
//
|
||
// We just got detach user indication from the wire.
|
||
//
|
||
err = FlushRosterData();
|
||
}
|
||
|
||
if (err != GCC_NO_ERROR)
|
||
{
|
||
ERROR_OUT(("CConf::ProcessDetachUserIndication: Error occured when flushing the rosters, err=%d", err));
|
||
InitiateTermination((err == GCC_ALLOCATION_FAILURE) ?
|
||
GCC_REASON_ERROR_LOW_RESOURCES :
|
||
GCC_REASON_ERROR_TERMINATION,
|
||
0);
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessDetachUserIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessTerminateRequest ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a terminate request received from the MCSUser
|
||
* object.
|
||
*
|
||
* Formal Parameters:
|
||
* requester_id - User ID of node that is requesting the terminate.
|
||
* reason - Reason for termination.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessTerminateRequest
|
||
(
|
||
UserID requester_id,
|
||
GCCReason reason
|
||
)
|
||
{
|
||
DebugEntry(CConf::ProcessTerminateRequest);
|
||
|
||
if (DoesRequesterHavePrivilege(requester_id, TERMINATE_PRIVILEGE))
|
||
{
|
||
TRACE_OUT(("CConf::ProcessTerminateRequest: Node has permission to terminate"));
|
||
|
||
/*
|
||
** Since the terminate was successful, we go ahead and set the
|
||
** m_fConfIsEstablished instance variable to FALSE. This prevents
|
||
** any other messages from flowing to the SAPs other than terminate
|
||
** messages.
|
||
*/
|
||
m_fConfIsEstablished = FALSE;
|
||
|
||
// Send a positive response to the requesting node
|
||
m_pMcsUserObject->ConferenceTerminateResponse(requester_id, GCC_RESULT_SUCCESSFUL);
|
||
|
||
/*
|
||
** This request will kick off a terminate at this node as well as
|
||
** all the nodes below this node in the connection hierarchy.
|
||
*/
|
||
m_pMcsUserObject->ConferenceTerminateIndication(reason);
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::ProcessTerminateRequest: Node does NOT have permission to terminate"));
|
||
// Send a negative response to the requesting node
|
||
m_pMcsUserObject->ConferenceTerminateResponse(requester_id, GCC_RESULT_INVALID_REQUESTER);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessTerminateRequest);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessTerminateIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine takes care of both a normal termination through
|
||
* a terminate pdu and termination that occurs due to a parent
|
||
* node disconnecting.
|
||
*
|
||
* Formal Parameters:
|
||
* reason - Reason for termination.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessTerminateIndication ( GCCReason gcc_reason )
|
||
{
|
||
UserID user_id;
|
||
|
||
DebugEntry(CConf::ProcessTerminateIndication);
|
||
|
||
/*
|
||
** Setting this to true here will insure that a terminate indication
|
||
** will be delivered to the control SAP.
|
||
*/
|
||
m_fConfTerminatePending = TRUE;
|
||
|
||
if (gcc_reason == GCC_REASON_PARENT_DISCONNECTED)
|
||
{
|
||
TRACE_OUT(("CConf::ProcessTerminateIndication: Terminate due to parent disconnecting"));
|
||
user_id = m_pMcsUserObject->GetMyNodeID();
|
||
}
|
||
else
|
||
if (m_ConnHandleList.IsEmpty())
|
||
{
|
||
TRACE_OUT(("CConf: ProcessTerminateIndication: Terminate due to request (no child connections)"));
|
||
/*
|
||
** Since there is a flaw in the terminate indication PDU were the
|
||
** node id that requested the termination is not sent we always
|
||
** assume here that the request came from the top provider (which
|
||
** is only partially true).
|
||
*/
|
||
user_id = m_pMcsUserObject->GetTopNodeID();
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::ProcessTerminateIndication: Wait till children disconnect before terminating"));
|
||
|
||
/*
|
||
** Wait until disconnect provider indications are received on all the
|
||
** child connections before terminating the conference.
|
||
*/
|
||
|
||
m_eConfTerminateReason = gcc_reason;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
m_pConfTerminateAlarm = new Alarm (TERMINATE_TIMER_DURATION);
|
||
if (NULL != m_pConfTerminateAlarm)
|
||
{
|
||
// let's wait, bail out without initiating termination.
|
||
goto MyExit;
|
||
}
|
||
|
||
// Go ahead and terminate if there is a resource error
|
||
ERROR_OUT(("CConf: ProcessTerminateIndication: can't create terminate alarm"));
|
||
user_id = m_pMcsUserObject->GetTopNodeID();
|
||
}
|
||
|
||
InitiateTermination(gcc_reason, user_id);
|
||
|
||
MyExit:
|
||
|
||
DebugExitVOID(CConf::ProcessTerminateIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessUserIDIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine is responsible for matching incomming user IDs with
|
||
* tag numbers returned by the subordinate node.
|
||
*
|
||
* Formal Parameters:
|
||
* tag_number - Tag used to match incomming user ID indication.
|
||
* user_id - User ID of node sending the indication.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
// checkpoint
|
||
void CConf::
|
||
ProcessUserIDIndication
|
||
(
|
||
TagNumber tag_number,
|
||
UserID user_id
|
||
)
|
||
{
|
||
INVITE_REQ_INFO *invite_request_info;
|
||
ConnectionHandle nConnHdl;
|
||
|
||
DebugEntry(CConf::ProcessUserIDIndication);
|
||
|
||
if (0 != (nConnHdl = m_ConnHdlTagNumberList2.Remove(tag_number)))
|
||
{
|
||
INVITE_REQ_INFO *lpInvReqInfo;
|
||
|
||
if (m_pMcsUserObject != NULL)
|
||
{
|
||
TRACE_OUT(("CConf: ProcessUserIDIndication: ID is set"));
|
||
|
||
m_pMcsUserObject->SetChildUserIDAndConnection(user_id, nConnHdl);
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::UserIDIndication: Error User Att. is NULL"));
|
||
}
|
||
|
||
/*
|
||
** Here we send an indication informing the node controller that
|
||
** a subordinate node has completed initialization.
|
||
*/
|
||
g_pControlSap->SubInitializationCompleteIndication (user_id, nConnHdl);
|
||
|
||
/*
|
||
** Now we determine if the responding node is the convener and if it
|
||
** is we will set up the m_nConvenerNodeID. This node id is used to
|
||
** determine privileges on certain GCC operations.
|
||
*/
|
||
if (m_nConvenerUserIDTagNumber == tag_number)
|
||
{
|
||
TRACE_OUT(("CConf::UserIDIndication: Convener Node ID is being set"));
|
||
m_nConvenerUserIDTagNumber = 0;
|
||
m_nConvenerNodeID = user_id;
|
||
}
|
||
|
||
/*
|
||
** If this is a User ID from an invited node we must pass the invite
|
||
** confirm to the Node Controller.
|
||
*/
|
||
m_InviteRequestList.Reset();
|
||
invite_request_info = NULL;
|
||
while (NULL != (lpInvReqInfo = m_InviteRequestList.Iterate()))
|
||
{
|
||
if (tag_number == lpInvReqInfo->invite_tag)
|
||
{
|
||
invite_request_info = lpInvReqInfo;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (invite_request_info != NULL)
|
||
{
|
||
g_pControlSap->ConfInviteConfirm(
|
||
m_nConfID,
|
||
invite_request_info->user_data_list,
|
||
GCC_RESULT_SUCCESSFUL,
|
||
invite_request_info->connection_handle);
|
||
|
||
// Free up user data if it exists
|
||
if (invite_request_info->user_data_list != NULL)
|
||
{
|
||
invite_request_info->user_data_list->Release();
|
||
}
|
||
|
||
// Cleanup the invite request list
|
||
m_InviteRequestList.Remove(invite_request_info);
|
||
|
||
// Free up the invite request info structure
|
||
delete invite_request_info;
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::ProcessUserIDIndication: Bad User ID Tag Number received"));
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessUserIDIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessUserCreateConfirm ()
|
||
*
|
||
* Private Function Description
|
||
* This routine handles the processes that occur after a user
|
||
* create confirm is received. This process will differ depending
|
||
* on what the node type is.
|
||
*
|
||
* Formal Parameters:
|
||
* result_value - Result of the user attachment being created.
|
||
* node_id - This nodes node id.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessUserCreateConfirm
|
||
(
|
||
UserResultType result_value,
|
||
UserID node_id
|
||
)
|
||
{
|
||
GCCError err = GCC_NO_ERROR;
|
||
PUChar encoded_pdu;
|
||
UINT encoded_pdu_length;
|
||
ConnectGCCPDU connect_pdu;
|
||
MCSError mcs_error;
|
||
GCCConferenceName conference_name;
|
||
GCCNumericString conference_modifier;
|
||
GCCNumericString remote_modifier = NULL;
|
||
BOOL is_top_provider;
|
||
|
||
DebugEntry(CConf::ProcessUserCreateConfirm);
|
||
|
||
if (result_value == USER_RESULT_SUCCESSFUL)
|
||
{
|
||
switch (m_eNodeType)
|
||
{
|
||
case TOP_PROVIDER_NODE:
|
||
/*
|
||
** Encode the tag number into the ConferenceCreateResponse
|
||
** PDU. If we have gotten this far the result is success.
|
||
*/
|
||
|
||
connect_pdu.choice = CONFERENCE_CREATE_RESPONSE_CHOSEN;
|
||
connect_pdu.u.conference_create_response.bit_mask = 0;
|
||
|
||
connect_pdu.u.conference_create_response.node_id = node_id;
|
||
|
||
/*
|
||
** Here we save this particular User ID tag and mark it as the
|
||
** conveners so that when the convener's user ID is returned
|
||
** the m_nConvenerNodeID instance variable can be properly
|
||
** initialized.
|
||
*/
|
||
m_nConvenerUserIDTagNumber = GetNewUserIDTag ();
|
||
connect_pdu.u.conference_create_response.tag = m_nConvenerUserIDTagNumber;
|
||
|
||
if (m_pUserDataList != NULL)
|
||
{
|
||
connect_pdu.u.conference_create_response.bit_mask |= CCRS_USER_DATA_PRESENT;
|
||
|
||
err = m_pUserDataList->GetUserDataPDU(
|
||
&connect_pdu.u.conference_create_response.ccrs_user_data);
|
||
if (err != GCC_NO_ERROR)
|
||
{
|
||
// Terminate conference due to resource error
|
||
InitiateTermination ( GCC_REASON_ERROR_LOW_RESOURCES,
|
||
0);
|
||
break;
|
||
}
|
||
}
|
||
|
||
connect_pdu.u.conference_create_response.result =
|
||
::TranslateGCCResultToCreateResult(GCC_RESULT_SUCCESSFUL);
|
||
|
||
if (g_GCCCoder->Encode((LPVOID) &connect_pdu,
|
||
CONNECT_GCC_PDU,
|
||
PACKED_ENCODING_RULES,
|
||
&encoded_pdu,
|
||
&encoded_pdu_length))
|
||
{
|
||
mcs_error = g_pMCSIntf->ConnectProviderResponse (
|
||
m_hConvenerConnection,
|
||
&m_nConfID,
|
||
m_pDomainParameters,
|
||
RESULT_SUCCESSFUL,
|
||
encoded_pdu,
|
||
encoded_pdu_length);
|
||
|
||
g_GCCCoder->FreeEncoded(encoded_pdu);
|
||
|
||
if (mcs_error == MCS_NO_ERROR)
|
||
{
|
||
m_fConfIsEstablished = TRUE;
|
||
|
||
/*
|
||
** Add the user's tag number to the list of
|
||
** outstanding user ids along with its associated
|
||
** connection.
|
||
*/
|
||
ASSERT(0 != m_hConvenerConnection);
|
||
m_ConnHdlTagNumberList2.Append(connect_pdu.u.conference_create_response.tag,
|
||
m_hConvenerConnection);
|
||
}
|
||
else if (mcs_error == MCS_DOMAIN_PARAMETERS_UNACCEPTABLE)
|
||
{
|
||
/*
|
||
** Inform the node controller that the reason
|
||
** the conference was terminated was that the
|
||
** domain parameter passed in the Create Response
|
||
** were unacceptable.
|
||
*/
|
||
InitiateTermination(GCC_REASON_DOMAIN_PARAMETERS_UNACCEPTABLE, 0);
|
||
}
|
||
else
|
||
{
|
||
InitiateTermination(GCC_REASON_MCS_RESOURCE_FAILURE, 0);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** A Fatal Resource error has occured. At this point
|
||
** the conference is invalid and should be terminated.
|
||
*/
|
||
ERROR_OUT(("CConf::ProcessUserCreateConfirm: can't encode. Terminate Conference"));
|
||
InitiateTermination(GCC_REASON_ERROR_LOW_RESOURCES, 0);
|
||
}
|
||
break;
|
||
|
||
case CONVENER_NODE:
|
||
/*
|
||
** Send the GCC User ID is here. This will require a call to
|
||
** the User Object. The tag number that was returned in
|
||
** the ConfCreateResponse call is used here.
|
||
*/
|
||
if (m_pMcsUserObject != NULL)
|
||
{
|
||
m_pMcsUserObject->SendUserIDRequest(m_nParentIDTagNumber);
|
||
}
|
||
|
||
// Fill in the conference name data pointers.
|
||
GetConferenceNameAndModifier(&conference_name, &conference_modifier);
|
||
|
||
g_pControlSap->ConfCreateConfirm(&conference_name,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
m_pDomainParameters,
|
||
m_pUserDataList,
|
||
GCC_RESULT_SUCCESSFUL,
|
||
m_hParentConnection);
|
||
|
||
// Free up the User Data List
|
||
if (m_pUserDataList != NULL)
|
||
{
|
||
m_pUserDataList->Release();
|
||
m_pUserDataList = NULL;
|
||
}
|
||
|
||
m_fConfIsEstablished = TRUE;
|
||
break;
|
||
|
||
case TOP_PROVIDER_AND_CONVENER_NODE:
|
||
/*
|
||
** First set up the convener node id. In this case it is
|
||
** identical to the node ID of the Top Provider which is this
|
||
** node.
|
||
*/
|
||
m_nConvenerNodeID = m_pMcsUserObject->GetMyNodeID();
|
||
|
||
// Fill in the conference name data pointers.
|
||
GetConferenceNameAndModifier( &conference_name,
|
||
&conference_modifier);
|
||
|
||
g_pControlSap->ConfCreateConfirm(
|
||
&conference_name,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
m_pDomainParameters,
|
||
NULL,
|
||
GCC_RESULT_SUCCESSFUL,
|
||
0); //Parent Connection
|
||
m_fConfIsEstablished = TRUE;
|
||
break;
|
||
|
||
case JOINED_NODE:
|
||
case JOINED_CONVENER_NODE:
|
||
/*
|
||
** Send the GCC User ID is here. This will require a call to
|
||
** the User Object. The tag number that was returned in
|
||
** the ConfCreateResponse call is used here.
|
||
*/
|
||
if (m_pMcsUserObject != NULL)
|
||
{
|
||
m_pMcsUserObject->SendUserIDRequest(m_nParentIDTagNumber);
|
||
}
|
||
|
||
// Fill in the conference name data pointers.
|
||
GetConferenceNameAndModifier( &conference_name,
|
||
&conference_modifier);
|
||
|
||
if (m_pszRemoteModifier != NULL)
|
||
{
|
||
remote_modifier = (GCCNumericString) m_pszRemoteModifier;
|
||
}
|
||
|
||
g_pControlSap->ConfJoinConfirm(
|
||
&conference_name,
|
||
remote_modifier,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
NULL,
|
||
m_pDomainParameters,
|
||
m_fClearPassword,
|
||
m_fConfLocked,
|
||
m_fConfListed,
|
||
m_fConfConductible,
|
||
m_eTerminationMethod,
|
||
m_pConductorPrivilegeList,
|
||
m_pConductModePrivilegeList,
|
||
m_pNonConductModePrivilegeList,
|
||
m_pwszConfDescription,
|
||
m_pUserDataList,
|
||
GCC_RESULT_SUCCESSFUL,
|
||
m_hParentConnection,
|
||
NULL,
|
||
0);
|
||
|
||
m_fConfIsEstablished = TRUE;
|
||
break;
|
||
|
||
case INVITED_NODE:
|
||
/*
|
||
** Send the GCC User ID here. This will require a call to
|
||
** the User Object.
|
||
*/
|
||
if (m_pMcsUserObject != NULL)
|
||
m_pMcsUserObject->SendUserIDRequest(m_nParentIDTagNumber);
|
||
|
||
m_fConfIsEstablished = TRUE;
|
||
break;
|
||
|
||
default:
|
||
TRACE_OUT(("CConf:UserCreateConfirm: Error: Bad User Type"));
|
||
break;
|
||
}
|
||
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
/*
|
||
** We now instantiate the conference roster manager to be used
|
||
** with this conference.
|
||
*/
|
||
if ((m_eNodeType == TOP_PROVIDER_NODE) ||
|
||
(m_eNodeType == TOP_PROVIDER_AND_CONVENER_NODE))
|
||
{
|
||
is_top_provider = TRUE;
|
||
}
|
||
else
|
||
is_top_provider = FALSE;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
m_pConfRosterMgr = new CConfRosterMgr(
|
||
m_pMcsUserObject,
|
||
this,
|
||
is_top_provider,
|
||
&err);
|
||
if (m_pConfRosterMgr == NULL)
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
|
||
/*
|
||
** We create the application registry object here because we now
|
||
** know the node type.
|
||
*/
|
||
if (err == GCC_NO_ERROR)
|
||
{
|
||
if ((m_eNodeType == TOP_PROVIDER_NODE) ||
|
||
(m_eNodeType == TOP_PROVIDER_AND_CONVENER_NODE))
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pAppRegistry = new CRegistry(
|
||
m_pMcsUserObject,
|
||
TRUE,
|
||
m_nConfID,
|
||
&m_AppRosterMgrList,
|
||
&err);
|
||
}
|
||
else
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pAppRegistry = new CRegistry(
|
||
m_pMcsUserObject,
|
||
FALSE,
|
||
m_nConfID,
|
||
&m_AppRosterMgrList,
|
||
&err);
|
||
}
|
||
}
|
||
|
||
if ((m_pAppRegistry != NULL) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
/*
|
||
** Inform the node controller that it is time to do an announce
|
||
** presence for this conference.
|
||
*/
|
||
g_pControlSap->ConfPermissionToAnnounce(m_nConfID, node_id);
|
||
|
||
/*
|
||
** Make the owner callback to inform that the owner object that
|
||
** the conference object was successfully created. This also
|
||
** kicks off the permission to enroll process.
|
||
*/
|
||
g_pGCCController->ProcessConfEstablished(m_nConfID);
|
||
|
||
/*
|
||
** For all nodes except the top provider node we allocate a
|
||
** startup alarm that is used to hold back all roster flushes
|
||
** for a certain length of time giving all the local APEs
|
||
** time to enroll. An allocation failure here is not FATAL
|
||
** since everything will work with or without this alarm.
|
||
** Without the Alarm there may be a bit more network traffic
|
||
** during the startup process. Note that there is no need
|
||
** for a startup alarm if there are no application SAPs.
|
||
*/
|
||
if ((m_eNodeType != TOP_PROVIDER_NODE) &&
|
||
(m_eNodeType != TOP_PROVIDER_AND_CONVENER_NODE))
|
||
{
|
||
TRACE_OUT(("CConf:ProcessUserCreateConfirm: Creating Startup Alarm"));
|
||
// m_pConfStartupAlarm = new Alarm(STARTUP_TIMER_DURATION);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf: UserCreateConfirm: Error initializing"));
|
||
InitiateTermination(GCC_REASON_ERROR_LOW_RESOURCES, 0);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf: UserCreateConfirm: Create of User Att. Failed"));
|
||
|
||
/*
|
||
** Try to properly cleanup here. Since the user creation failed
|
||
** the conference is no longer valid and needs to be cleaned up.
|
||
*/
|
||
switch (m_eNodeType)
|
||
{
|
||
case TOP_PROVIDER_NODE:
|
||
g_pMCSIntf->ConnectProviderResponse (
|
||
m_hConvenerConnection,
|
||
&m_nConfID,
|
||
m_pDomainParameters,
|
||
RESULT_UNSPECIFIED_FAILURE,
|
||
NULL, 0);
|
||
break;
|
||
|
||
case CONVENER_NODE:
|
||
case TOP_PROVIDER_AND_CONVENER_NODE:
|
||
GetConferenceNameAndModifier( &conference_name,
|
||
&conference_modifier);
|
||
|
||
g_pControlSap->ConfCreateConfirm(
|
||
&conference_name,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
m_pDomainParameters,
|
||
NULL,
|
||
GCC_RESULT_RESOURCES_UNAVAILABLE,
|
||
m_hParentConnection);
|
||
break;
|
||
|
||
case JOINED_NODE:
|
||
case JOINED_CONVENER_NODE:
|
||
GetConferenceNameAndModifier( &conference_name,
|
||
&conference_modifier);
|
||
|
||
if (m_pszRemoteModifier != NULL)
|
||
{
|
||
remote_modifier = (GCCNumericString) m_pszRemoteModifier;
|
||
}
|
||
|
||
g_pControlSap->ConfJoinConfirm(
|
||
&conference_name,
|
||
remote_modifier,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
NULL,
|
||
m_pDomainParameters,
|
||
m_fClearPassword,
|
||
m_fConfLocked,
|
||
m_fConfListed,
|
||
m_fConfConductible,
|
||
m_eTerminationMethod,
|
||
m_pConductorPrivilegeList,
|
||
m_pConductModePrivilegeList,
|
||
m_pNonConductModePrivilegeList,
|
||
m_pwszConfDescription,
|
||
m_pUserDataList,
|
||
GCC_RESULT_RESOURCES_UNAVAILABLE,
|
||
m_hParentConnection,
|
||
NULL,
|
||
0);
|
||
break;
|
||
|
||
case INVITED_NODE:
|
||
default:
|
||
break;
|
||
}
|
||
|
||
/*
|
||
** A Fatal Resource error has occured. At this point
|
||
** the conference is invalid and should be terminated.
|
||
*/
|
||
InitiateTermination(GCC_REASON_MCS_RESOURCE_FAILURE, 0);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessUserCreateConfirm);
|
||
}
|
||
|
||
|
||
// Calls received from the MCS interface
|
||
|
||
|
||
/*
|
||
* CConf::ProcessConnectProviderConfirm ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes connect provider confirms received
|
||
* directly from MCS.
|
||
*
|
||
* Formal Parameters:
|
||
* connect_provider_confirm - This structure contains the MCS related
|
||
* data such as sender id and connection
|
||
* Handle as well as the PDU data.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConnectProviderConfirm ( PConnectProviderConfirm connect_provider_confirm )
|
||
{
|
||
PPacket packet;
|
||
PConnectGCCPDU connect_pdu;
|
||
PacketError packet_error;
|
||
GCCResult result = GCC_RESULT_SUCCESSFUL;
|
||
GCCConferenceName conference_name;
|
||
GCCNumericString conference_modifier;
|
||
GCCNumericString remote_modifier = NULL;
|
||
INVITE_REQ_INFO *invite_request_info;
|
||
|
||
DebugEntry(CConf::ProcessConnectProviderConfirm);
|
||
|
||
if (connect_provider_confirm->user_data_length != 0)
|
||
{
|
||
/*
|
||
** If the result is success create the packet to be decoded from
|
||
** the PDU passed back in the MCS user data field. If creation
|
||
** failes this again is a FATAL error and the conference must be
|
||
** terminated.
|
||
*/
|
||
DBG_SAVE_FILE_LINE
|
||
packet = new Packet((PPacketCoder) g_GCCCoder,
|
||
PACKED_ENCODING_RULES,
|
||
connect_provider_confirm->user_data,
|
||
connect_provider_confirm->user_data_length,
|
||
CONNECT_GCC_PDU,
|
||
TRUE,
|
||
&packet_error);
|
||
if ((packet != NULL) && (packet_error == PACKET_NO_ERROR))
|
||
{
|
||
connect_pdu = (PConnectGCCPDU)packet->GetDecodedData();
|
||
/*
|
||
** If all the above succeeds then decode the packet based on
|
||
** which node type this is.
|
||
*/
|
||
switch (connect_pdu->choice)
|
||
{
|
||
case CONFERENCE_CREATE_RESPONSE_CHOSEN:
|
||
ProcessConferenceCreateResponsePDU (
|
||
&connect_pdu->u.conference_create_response,
|
||
connect_provider_confirm);
|
||
break;
|
||
|
||
case CONNECT_JOIN_RESPONSE_CHOSEN:
|
||
ProcessConferenceJoinResponsePDU (
|
||
&connect_pdu->u.connect_join_response,
|
||
connect_provider_confirm);
|
||
break;
|
||
|
||
case CONFERENCE_INVITE_RESPONSE_CHOSEN:
|
||
ProcessConferenceInviteResponsePDU (
|
||
&connect_pdu->u.conference_invite_response,
|
||
connect_provider_confirm );
|
||
break;
|
||
|
||
default:
|
||
ERROR_OUT(("CConf:ProcessConnectProviderConfirm: "
|
||
"Error: Received Invalid Connect Provider Confirm"));
|
||
break;
|
||
}
|
||
|
||
// Free the decoded packet
|
||
packet->Unlock ();
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf: ProcessConnectProviderConfirm:"
|
||
"Incompatible protocol occured"));
|
||
result = GCC_RESULT_INCOMPATIBLE_PROTOCOL;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ProcessConnectProviderConfirm: result=%d", (UINT) connect_provider_confirm->result));
|
||
|
||
/*
|
||
** This section of the code assumes that there is no connect PDU in
|
||
** the returned packet. First determine what the result is. We
|
||
** assume that if the MCS connection was rejected due to
|
||
** parameters being unacceptable and no GCC pdu was returned that there
|
||
** was a protocol incompatibility.
|
||
*/
|
||
if (connect_provider_confirm->result == RESULT_PARAMETERS_UNACCEPTABLE)
|
||
result = GCC_RESULT_INCOMPATIBLE_PROTOCOL;
|
||
else
|
||
{
|
||
result = ::TranslateMCSResultToGCCResult(connect_provider_confirm->result);
|
||
}
|
||
}
|
||
|
||
// Handle any errors that might have occured.
|
||
if (result != GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
INVITE_REQ_INFO *lpInvReqInfo;
|
||
|
||
// First check to see if there are any outstanding invite request
|
||
m_InviteRequestList.Reset();
|
||
invite_request_info = NULL;
|
||
while (NULL != (lpInvReqInfo = m_InviteRequestList.Iterate()))
|
||
{
|
||
if (connect_provider_confirm->connection_handle == lpInvReqInfo->connection_handle)
|
||
{
|
||
TRACE_OUT(("CConf: ProcessConnectProviderConfirm: Found Invite Request Match"));
|
||
invite_request_info = lpInvReqInfo;
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
if (invite_request_info != NULL)
|
||
{
|
||
// This must be the confirm of an invite
|
||
ProcessConferenceInviteResponsePDU (NULL, connect_provider_confirm);
|
||
}
|
||
else
|
||
{
|
||
switch (m_eNodeType)
|
||
{
|
||
case CONVENER_NODE:
|
||
case TOP_PROVIDER_AND_CONVENER_NODE:
|
||
GetConferenceNameAndModifier ( &conference_name,
|
||
&conference_modifier);
|
||
|
||
g_pControlSap->ConfCreateConfirm(
|
||
&conference_name,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
m_pDomainParameters,
|
||
NULL,
|
||
result,
|
||
connect_provider_confirm->connection_handle);
|
||
|
||
InitiateTermination ( GCC_REASON_ERROR_TERMINATION,
|
||
0);
|
||
break;
|
||
|
||
case JOINED_NODE:
|
||
case JOINED_CONVENER_NODE:
|
||
TRACE_OUT(("CConf::ProcessConnectProviderConfirm:"
|
||
"Joined Node connect provider failed"));
|
||
GetConferenceNameAndModifier ( &conference_name,
|
||
&conference_modifier);
|
||
|
||
if (m_pszRemoteModifier != NULL)
|
||
{
|
||
remote_modifier = (GCCNumericString) m_pszRemoteModifier;
|
||
}
|
||
|
||
TRACE_OUT(("CConf::ProcessConnectProviderConfirm: Before conference Join Confirm"));
|
||
g_pControlSap->ConfJoinConfirm(
|
||
&conference_name,
|
||
remote_modifier,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
NULL,
|
||
m_pDomainParameters,
|
||
m_fClearPassword,
|
||
m_fConfLocked,
|
||
m_fConfListed,
|
||
m_fConfConductible,
|
||
m_eTerminationMethod,
|
||
m_pConductorPrivilegeList,
|
||
m_pConductModePrivilegeList,
|
||
m_pNonConductModePrivilegeList,
|
||
NULL,
|
||
NULL,
|
||
result,
|
||
connect_provider_confirm->connection_handle,
|
||
NULL,
|
||
0);
|
||
|
||
TRACE_OUT(("CConf::ProcessConnectProviderConfirm: After conference Join Confirm"));
|
||
|
||
InitiateTermination(GCC_REASON_ERROR_TERMINATION, 0);
|
||
break;
|
||
|
||
default:
|
||
TRACE_OUT(("CConf: ProcessConnectProviderConfirm:"
|
||
"Assertion Failure: Bad confirm received"));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConnectProviderConfirm);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* void ProcessConferenceCreateResponsePDU ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a Conference Create Response PDU that is
|
||
* delivered as part of a Connect Provider Confirm.
|
||
*
|
||
* Formal Parameters:
|
||
* create_response - This is the Conference Create response
|
||
* PDU.
|
||
* connect_provider_confirm - This structure contains the MCS related
|
||
* data such as sender id and connection
|
||
* Handle as well as the PDU data.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceCreateResponsePDU
|
||
(
|
||
PConferenceCreateResponse create_response,
|
||
PConnectProviderConfirm connect_provider_confirm
|
||
)
|
||
{
|
||
GCCError err = GCC_NO_ERROR;
|
||
GCCResult result;
|
||
UserID top_gcc_node_id;
|
||
UserID parent_user_id;
|
||
GCCConferenceName conference_name;
|
||
GCCNumericString conference_modifier;
|
||
|
||
DebugEntry(CConf::ProcessConnectProviderConfirm);
|
||
|
||
// Translate the result back to GCC Result
|
||
result = ::TranslateCreateResultToGCCResult(create_response->result);
|
||
|
||
if ((result == GCC_RESULT_SUCCESSFUL) &&
|
||
(connect_provider_confirm->result == RESULT_SUCCESSFUL))
|
||
{
|
||
/*
|
||
** Save the domain parameters. The domain parameters returned in
|
||
** the connect provider confirm should always be up to date.
|
||
*/
|
||
if (m_pDomainParameters == NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pDomainParameters = new DomainParameters;
|
||
}
|
||
|
||
if (m_pDomainParameters != NULL)
|
||
*m_pDomainParameters = connect_provider_confirm->domain_parameters;
|
||
else
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
|
||
// Get any user data that might exists
|
||
if ((create_response->bit_mask & CCRS_USER_DATA_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pUserDataList = new CUserDataListContainer(create_response->ccrs_user_data, &err);
|
||
if (m_pUserDataList == NULL)
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
|
||
if (err == GCC_NO_ERROR)
|
||
{
|
||
m_nParentIDTagNumber = create_response->tag;
|
||
|
||
top_gcc_node_id = create_response->node_id;
|
||
parent_user_id = top_gcc_node_id;
|
||
|
||
// Create the user attachment object.
|
||
DBG_SAVE_FILE_LINE
|
||
m_pMcsUserObject = new MCSUser(this, top_gcc_node_id, parent_user_id, &err);
|
||
if (m_pMcsUserObject == NULL || GCC_NO_ERROR != err)
|
||
{
|
||
if (NULL != m_pMcsUserObject)
|
||
{
|
||
m_pMcsUserObject->Release();
|
||
m_pMcsUserObject = NULL;
|
||
}
|
||
else
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf: ProcessConnectProviderConfirm: conference create result was Failure"));
|
||
|
||
// Go ahead and translate the mcs error to a gcc error if one occured.
|
||
if ((result == GCC_RESULT_SUCCESSFUL) &&
|
||
(connect_provider_confirm->result != RESULT_SUCCESSFUL))
|
||
{
|
||
result = ::TranslateMCSResultToGCCResult(connect_provider_confirm->result);
|
||
}
|
||
|
||
// Get the conference name to pass back in the create confirm
|
||
GetConferenceNameAndModifier ( &conference_name,
|
||
&conference_modifier);
|
||
|
||
g_pControlSap->ConfCreateConfirm(
|
||
&conference_name,
|
||
conference_modifier,
|
||
m_nConfID,
|
||
m_pDomainParameters,
|
||
NULL,
|
||
result,
|
||
connect_provider_confirm->connection_handle);
|
||
|
||
// Terminate the conference
|
||
InitiateTermination ( GCC_REASON_NORMAL_TERMINATION,
|
||
0);
|
||
}
|
||
|
||
|
||
if (err != GCC_NO_ERROR)
|
||
{
|
||
InitiateTermination ( GCC_REASON_ERROR_LOW_RESOURCES,
|
||
0);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConnectProviderConfirm);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* void ProcessConferenceJoinResponsePDU ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a Conference Join Response PDU that is
|
||
* delivered as part of a Connect Provider Confirm.
|
||
*
|
||
* Formal Parameters:
|
||
* join_response - This is the Conference Join response
|
||
* PDU.
|
||
* connect_provider_confirm - This structure contains the MCS related
|
||
* data such as sender id and connection
|
||
* Handle as well as the PDU data.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceJoinResponsePDU
|
||
(
|
||
PConferenceJoinResponse join_response,
|
||
PConnectProviderConfirm connect_provider_confirm
|
||
)
|
||
{
|
||
GCCError err = GCC_NO_ERROR;
|
||
GCCResult result;
|
||
UserID top_gcc_node_id;
|
||
UserID parent_user_id;
|
||
CPassword *password_challenge = NULL;
|
||
CUserDataListContainer *user_data_list = NULL;
|
||
GCCConferenceName conference_name;
|
||
GCCNumericString local_modifier;
|
||
GCCNumericString remote_modifier = NULL;
|
||
|
||
DebugEntry(CConf::ProcessConferenceJoinResponsePDU);
|
||
|
||
// Translate the result back to GCC Result
|
||
result = ::TranslateJoinResultToGCCResult (join_response->result);
|
||
|
||
if ((result == GCC_RESULT_SUCCESSFUL) &&
|
||
(connect_provider_confirm->result == RESULT_SUCCESSFUL))
|
||
{
|
||
/*
|
||
** Save the domain parameters. The domain parameters returned in
|
||
** the connect provider confirm should always be up to date.
|
||
*/
|
||
if (m_pDomainParameters == NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pDomainParameters = new DomainParameters;
|
||
}
|
||
|
||
if (m_pDomainParameters != NULL)
|
||
*m_pDomainParameters = connect_provider_confirm->domain_parameters;
|
||
else
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
|
||
// Get the conference name alias if one exists
|
||
if ((join_response->bit_mask & CONFERENCE_NAME_ALIAS_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
if (join_response->conference_name_alias.choice ==
|
||
NAME_SELECTOR_NUMERIC_CHOSEN)
|
||
{
|
||
delete m_pszConfNumericName;
|
||
if (NULL == (m_pszConfNumericName = ::My_strdupA(
|
||
join_response->conference_name_alias.u.name_selector_numeric)))
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
delete m_pwszConfTextName;
|
||
if (NULL == (m_pwszConfTextName = ::My_strdupW2(
|
||
join_response->conference_name_alias.u.name_selector_text.length,
|
||
join_response->conference_name_alias.u.name_selector_text.value)))
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Get the conductor privilege list if one exists
|
||
if ((join_response->bit_mask & CJRS_CONDUCTOR_PRIVS_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
delete m_pConductorPrivilegeList;
|
||
DBG_SAVE_FILE_LINE
|
||
m_pConductorPrivilegeList = new PrivilegeListData(join_response->cjrs_conductor_privs);
|
||
if (m_pConductorPrivilegeList == NULL)
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
|
||
// Get the conducted mode privilege list if one exists
|
||
if ((join_response->bit_mask & CJRS_CONDUCTED_PRIVS_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
delete m_pConductModePrivilegeList;
|
||
DBG_SAVE_FILE_LINE
|
||
m_pConductModePrivilegeList = new PrivilegeListData(join_response->cjrs_conducted_privs);
|
||
if (m_pConductModePrivilegeList == NULL)
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
|
||
// Get the non-conducted mode privilege list if one exists
|
||
if ((join_response->bit_mask & CJRS_NON_CONDUCTED_PRIVS_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
delete m_pNonConductModePrivilegeList;
|
||
DBG_SAVE_FILE_LINE
|
||
m_pNonConductModePrivilegeList = new PrivilegeListData(join_response->cjrs_non_conducted_privs);
|
||
if (m_pNonConductModePrivilegeList == NULL)
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
|
||
// Get the conference description if it exists
|
||
if ((join_response->bit_mask & CJRS_DESCRIPTION_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
delete m_pwszConfDescription;
|
||
if (NULL == (m_pwszConfDescription = ::My_strdupW2(
|
||
join_response->cjrs_description.length,
|
||
join_response->cjrs_description.value)))
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
|
||
// Get the user data if it exists
|
||
if ((join_response->bit_mask & CJRS_USER_DATA_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
if (NULL != m_pUserDataList)
|
||
{
|
||
m_pUserDataList->Release();
|
||
}
|
||
DBG_SAVE_FILE_LINE
|
||
m_pUserDataList = new CUserDataListContainer(join_response->cjrs_user_data, &err);
|
||
// in case of err but valid m_pUserDataList, the destructor will clean it up.
|
||
if (m_pUserDataList == NULL)
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
|
||
if (err == GCC_NO_ERROR)
|
||
{
|
||
parent_user_id = (join_response->bit_mask & CJRS_NODE_ID_PRESENT) ?
|
||
(UserID) join_response->cjrs_node_id :
|
||
(UserID) join_response->top_node_id;
|
||
|
||
m_nParentIDTagNumber = join_response->tag;
|
||
top_gcc_node_id = (UserID)join_response->top_node_id;
|
||
m_fClearPassword = join_response->clear_password_required;
|
||
m_fConfLocked = join_response->conference_is_locked;
|
||
m_fConfListed = join_response->conference_is_listed;
|
||
m_eTerminationMethod = (GCCTerminationMethod)join_response->termination_method;
|
||
m_fConfConductible = join_response->conference_is_conductible;
|
||
|
||
// Create the user attachment object.
|
||
ASSERT(NULL == m_pMcsUserObject);
|
||
DBG_SAVE_FILE_LINE
|
||
m_pMcsUserObject = new MCSUser(this, top_gcc_node_id, parent_user_id, &err);
|
||
// in case of err but valid m_pMcsUserObject, the destructor will clean it up.
|
||
if (m_pMcsUserObject == NULL)
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if ((join_response->bit_mask & CJRS_PASSWORD_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
password_challenge = new CPassword(&join_response->cjrs_password, &err);
|
||
if (password_challenge == NULL)
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
|
||
// Get the user data if it exists
|
||
if ((join_response->bit_mask & CJRS_USER_DATA_PRESENT) &&
|
||
(err == GCC_NO_ERROR))
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
user_data_list = new CUserDataListContainer(join_response->cjrs_user_data, &err);
|
||
if (user_data_list == NULL)
|
||
{
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
|
||
if (err == GCC_NO_ERROR)
|
||
{
|
||
/*
|
||
** Go ahead and translate the mcs error to a gcc error if
|
||
** one occured.
|
||
*/
|
||
if ((result == GCC_RESULT_SUCCESSFUL) &&
|
||
(connect_provider_confirm->result != RESULT_SUCCESSFUL))
|
||
{
|
||
result = ::TranslateMCSResultToGCCResult(connect_provider_confirm->result);
|
||
}
|
||
|
||
// Fill in the conference name data pointers.
|
||
GetConferenceNameAndModifier(&conference_name, &local_modifier);
|
||
|
||
if (m_pszRemoteModifier != NULL)
|
||
{
|
||
remote_modifier = (GCCNumericString) m_pszRemoteModifier;
|
||
}
|
||
|
||
//
|
||
// LONCHANC: To get rid of the conference object
|
||
// in GCC Controller's active conference list.
|
||
// The conference object will then be moved to
|
||
// the deletion list.
|
||
//
|
||
InitiateTermination ( GCC_REASON_NORMAL_TERMINATION, 0);
|
||
|
||
g_pControlSap->ConfJoinConfirm(
|
||
&conference_name,
|
||
remote_modifier,
|
||
local_modifier,
|
||
m_nConfID,
|
||
password_challenge,
|
||
m_pDomainParameters,
|
||
m_fClearPassword,
|
||
m_fConfLocked,
|
||
m_fConfListed,
|
||
m_fConfConductible,
|
||
m_eTerminationMethod,
|
||
m_pConductorPrivilegeList,
|
||
m_pConductModePrivilegeList,
|
||
m_pNonConductModePrivilegeList,
|
||
NULL,
|
||
user_data_list,
|
||
result,
|
||
connect_provider_confirm->connection_handle,
|
||
connect_provider_confirm->pb_cred,
|
||
connect_provider_confirm->cb_cred);
|
||
}
|
||
|
||
if (password_challenge != NULL)
|
||
{
|
||
password_challenge->Release();
|
||
}
|
||
|
||
if (user_data_list != NULL)
|
||
{
|
||
user_data_list->Release();
|
||
}
|
||
}
|
||
|
||
if (err != GCC_NO_ERROR)
|
||
{
|
||
InitiateTermination (GCC_REASON_ERROR_LOW_RESOURCES, 0);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceJoinResponsePDU);
|
||
}
|
||
|
||
|
||
/*
|
||
* void ProcessConferenceInviteResponsePDU ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a Conference Invite Response PDU that is
|
||
* delivered as part of a Connect Provider Confirm.
|
||
*
|
||
* Formal Parameters:
|
||
* invite_response - This is the Conference Invite response
|
||
* PDU.
|
||
* connect_provider_confirm - This structure contains the MCS related
|
||
* data such as sender id and connection
|
||
* Handle as well as the PDU data.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceInviteResponsePDU
|
||
(
|
||
PConferenceInviteResponse invite_response,
|
||
PConnectProviderConfirm connect_provider_confirm
|
||
)
|
||
{
|
||
GCCError err;
|
||
GCCResult result;
|
||
CUserDataListContainer *user_data_list = NULL;
|
||
INVITE_REQ_INFO *invite_request_info = NULL;
|
||
INVITE_REQ_INFO *lpInvReqInfo;
|
||
|
||
DebugEntry(CConf::ProcessConferenceInviteResponsePDU);
|
||
|
||
// First obtain the info request info structure.
|
||
m_InviteRequestList.Reset();
|
||
while (NULL != (lpInvReqInfo = m_InviteRequestList.Iterate()))
|
||
{
|
||
if (connect_provider_confirm->connection_handle == lpInvReqInfo->connection_handle)
|
||
{
|
||
invite_request_info = lpInvReqInfo;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (invite_request_info == NULL)
|
||
return;
|
||
|
||
if (invite_response != NULL)
|
||
{
|
||
// Get the user data list if one exists
|
||
if (invite_response->bit_mask & CIRS_USER_DATA_PRESENT)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
user_data_list = new CUserDataListContainer(invite_response->cirs_user_data, &err);
|
||
}
|
||
|
||
// Translate the result to GCCResult
|
||
result = ::TranslateInviteResultToGCCResult(invite_response->result);
|
||
}
|
||
else
|
||
{
|
||
result = (connect_provider_confirm->result == RESULT_USER_REJECTED) ?
|
||
GCC_RESULT_INCOMPATIBLE_PROTOCOL :
|
||
::TranslateMCSResultToGCCResult(connect_provider_confirm->result);
|
||
}
|
||
|
||
if ((result == GCC_RESULT_SUCCESSFUL) &&
|
||
(connect_provider_confirm->result == RESULT_SUCCESSFUL))
|
||
{
|
||
TRACE_OUT(("CConf::ProcessConferenceInviteResponsePDU:"
|
||
"Received Connect Provider confirm on Invite"));
|
||
|
||
/*
|
||
** Save the domain parameters. The domain parameters returned in
|
||
** the connect provider confirm should always be up to date.
|
||
*/
|
||
if (m_pDomainParameters == NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pDomainParameters = new DomainParameters;
|
||
}
|
||
|
||
if (m_pDomainParameters != NULL)
|
||
*m_pDomainParameters = connect_provider_confirm->domain_parameters;
|
||
else
|
||
err = GCC_ALLOCATION_FAILURE;
|
||
|
||
// Save the user data list for the invite confirm
|
||
invite_request_info->user_data_list = user_data_list;
|
||
|
||
// Wait for user ID from invited node before sending invite confirm.
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Go ahead and translate the mcs error to a gcc error if
|
||
** one occured.
|
||
*/
|
||
if ((result == GCC_RESULT_SUCCESSFUL) &&
|
||
(connect_provider_confirm->result != RESULT_SUCCESSFUL))
|
||
{
|
||
result = ::TranslateMCSResultToGCCResult(connect_provider_confirm->result);
|
||
}
|
||
|
||
// Cleanup the connection handle list
|
||
ASSERT(0 != connect_provider_confirm->connection_handle);
|
||
m_ConnHandleList.Remove(connect_provider_confirm->connection_handle);
|
||
|
||
// In case of error, the node controller will delete this conference.
|
||
// AddRef here to protect itself from going away.
|
||
AddRef();
|
||
|
||
g_pControlSap->ConfInviteConfirm(
|
||
m_nConfID,
|
||
user_data_list,
|
||
result,
|
||
connect_provider_confirm->connection_handle);
|
||
|
||
// Free up the user data
|
||
if (user_data_list != NULL)
|
||
{
|
||
user_data_list->Release();
|
||
}
|
||
|
||
// The reason that we check this is because in some cases, in the call to
|
||
// g_pControlSap->ConfInviteConfirm, someone was calling DeleteOutstandingInviteRequests
|
||
// which was killing the list via a call to m_InviteRequestList.Clear...
|
||
// This happens when the calee refuses to accept the call
|
||
if(m_InviteRequestList.Remove(invite_request_info))
|
||
{
|
||
// Free up the invite request info structure
|
||
delete invite_request_info;
|
||
}
|
||
|
||
// To match AddRef above.
|
||
Release();
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceInviteResponsePDU);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessEjectUserIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes an Eject User Indication.
|
||
*
|
||
* Formal Parameters:
|
||
* reason - Reason that this node is being ejected.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessEjectUserIndication ( GCCReason reason )
|
||
{
|
||
DebugEntry(CConf::ProcessEjectUserIndication);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
/*
|
||
** First inform the control SAP that this node has been ejected from this
|
||
** particular conference.
|
||
*/
|
||
g_pControlSap->ConfEjectUserIndication(
|
||
m_nConfID,
|
||
reason,
|
||
m_pMcsUserObject->GetMyNodeID());
|
||
|
||
/*
|
||
** Next we set conference established to FALSE since the conference is
|
||
** no longer established (this also prevents a terminate indication from
|
||
** being sent).
|
||
*/
|
||
m_fConfIsEstablished = FALSE;
|
||
|
||
InitiateTermination(reason, m_pMcsUserObject->GetMyNodeID());
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessEjectUserIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessEjectUserRequest ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes an eject user request PDU. This routine should
|
||
* only be called from the Top Provider.
|
||
*
|
||
* Formal Parameters:
|
||
* eject_node_request - This is the PDU data associated with the
|
||
* eject user request.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessEjectUserRequest ( PUserEjectNodeRequestInfo eject_node_request )
|
||
{
|
||
GCCResult result;
|
||
|
||
DebugEntry(CConf::ProcessEjectUserRequest);
|
||
|
||
// Check to make sure that the requesting node has the proper privileges
|
||
if (DoesRequesterHavePrivilege( eject_node_request->requester_id,
|
||
EJECT_USER_PRIVILEGE))
|
||
{
|
||
/*
|
||
** The user attachment object decides where the eject should
|
||
** be sent (either to the Top Provider or conference wide as
|
||
** an indication.
|
||
*/
|
||
m_pMcsUserObject->EjectNodeFromConference (
|
||
eject_node_request->node_to_eject,
|
||
eject_node_request->reason);
|
||
|
||
result = GCC_RESULT_SUCCESSFUL;
|
||
}
|
||
else
|
||
result = GCC_RESULT_INVALID_REQUESTER;
|
||
|
||
m_pMcsUserObject->SendEjectNodeResponse (eject_node_request->requester_id,
|
||
eject_node_request->node_to_eject,
|
||
result);
|
||
|
||
DebugExitVOID(CConf::ProcessEjectUserRequest);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessEjectUserResponse ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes an eject user response PDU. This routine is
|
||
* called in response to an eject user request.
|
||
*
|
||
* Formal Parameters:
|
||
* eject_node_response - This is the PDU data associated with the
|
||
* eject user response.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessEjectUserResponse ( PUserEjectNodeResponseInfo eject_node_response )
|
||
{
|
||
DebugEntry(CConf::ProcessEjectUserResponse);
|
||
|
||
if (m_EjectedNodeConfirmList.Remove(eject_node_response->node_to_eject))
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfEjectUserConfirm(
|
||
m_nConfID,
|
||
eject_node_response->node_to_eject,
|
||
eject_node_response->result);
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ProcessEjectUserResponse: Assertion: Bad ejected node response received"));
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessEjectUserResponse);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessConferenceLockRequest()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conference lock request PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* requester_id - Node ID of node making the lock request.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceLockRequest ( UserID requester_id )
|
||
{
|
||
DebugEntry(CConf::ProcessConferenceLockRequest);
|
||
|
||
if (DoesRequesterHavePrivilege (requester_id,
|
||
LOCK_UNLOCK_PRIVILEGE))
|
||
{
|
||
g_pControlSap->ConfLockIndication(m_nConfID, requester_id);
|
||
}
|
||
else
|
||
{
|
||
if (requester_id == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfLockConfirm(GCC_RESULT_INVALID_REQUESTER, m_nConfID);
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
m_pMcsUserObject->SendConferenceLockResponse(
|
||
requester_id,
|
||
GCC_RESULT_INVALID_REQUESTER);
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceLockRequest);
|
||
}
|
||
|
||
/*
|
||
* CConf::ProcessConferenceUnlockRequest()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conference unlock request PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* requester_id - Node ID of node making the unlock request.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceUnlockRequest ( UserID requester_id )
|
||
{
|
||
DebugEntry(CConf::ProcessConferenceUnlockRequest);
|
||
|
||
if (DoesRequesterHavePrivilege (requester_id,
|
||
LOCK_UNLOCK_PRIVILEGE))
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfUnlockIndication(m_nConfID, requester_id);
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
if (requester_id == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfUnlockConfirm(GCC_RESULT_INVALID_REQUESTER, m_nConfID);
|
||
#endif // JASPER
|
||
}
|
||
else
|
||
{
|
||
m_pMcsUserObject->SendConferenceUnlockResponse(
|
||
requester_id,
|
||
GCC_RESULT_INVALID_REQUESTER);
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceUnlockRequest);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessConferenceLockIndication()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conference lock indication PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* source_id - Node ID which sent out the lock indication. Should
|
||
* only be sent by the top provider.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceLockIndication ( UserID source_id )
|
||
{
|
||
DebugEntry(CConf::ProcessConferenceLockIndication);
|
||
|
||
if (source_id == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
m_fConfLocked = CONFERENCE_IS_LOCKED;
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfLockReport(m_nConfID, m_fConfLocked);
|
||
#endif // JASPER
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceLockIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessConferenceUnlockIndication()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conference unlock indication PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* source_id - Node ID which sent out the unlock indication. Should
|
||
* only be sent by the top provider.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceUnlockIndication ( UserID source_id )
|
||
{
|
||
DebugEntry(CConf::ProcessConferenceUnlockIndication);
|
||
|
||
if (source_id == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
m_fConfLocked = CONFERENCE_IS_NOT_LOCKED;
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfLockReport(m_nConfID, m_fConfLocked);
|
||
#endif // JASPER
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceUnlockIndication);
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* void ProcessConferenceTransferRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This routine processes a conference transfer request PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* requesting_node_id - Node ID that made the transfer
|
||
* request.
|
||
* destination_conference_name - The name of the conference to
|
||
* transfer to.
|
||
* destination_conference_modifier - The name of the conference modifier
|
||
* to transfer to.
|
||
* destination_address_list - Network address list of the
|
||
* conference to transfer to.
|
||
* number_of_destination_nodes - The number of nodes in the list of
|
||
* nodes that should perform the
|
||
* transfer.
|
||
* destination_node_list - The list of nodes that should
|
||
* perform the transfer.
|
||
* password - The password needed to join the
|
||
* new conference.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceTransferRequest
|
||
(
|
||
UserID requesting_node_id,
|
||
PGCCConferenceName destination_conference_name,
|
||
GCCNumericString destination_conference_modifier,
|
||
CNetAddrListContainer *destination_address_list,
|
||
UINT number_of_destination_nodes,
|
||
PUserID destination_node_list,
|
||
CPassword *password
|
||
)
|
||
{
|
||
GCCResult result;
|
||
|
||
DebugEntry(CConf::ProcessConferenceTransferRequest);
|
||
|
||
if (DoesRequesterHavePrivilege( requesting_node_id,
|
||
TRANSFER_PRIVILEGE))
|
||
{
|
||
result = GCC_RESULT_SUCCESSFUL;
|
||
}
|
||
else
|
||
result = GCC_RESULT_INVALID_REQUESTER;
|
||
|
||
m_pMcsUserObject->ConferenceTransferResponse (
|
||
requesting_node_id,
|
||
destination_conference_name,
|
||
destination_conference_modifier,
|
||
number_of_destination_nodes,
|
||
destination_node_list,
|
||
result);
|
||
|
||
if (result == GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
m_pMcsUserObject->ConferenceTransferIndication (
|
||
destination_conference_name,
|
||
destination_conference_modifier,
|
||
destination_address_list,
|
||
number_of_destination_nodes,
|
||
destination_node_list,
|
||
password);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceTransferRequest);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ProcessConferenceAddRequest ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conference add request PDU.
|
||
*
|
||
* Formal Parameters:
|
||
* requesting_node_id - Node ID that made the transfer
|
||
* request.
|
||
* destination_conference_name - The name of the conference to
|
||
* transfer to.
|
||
* destination_conference_modifier - The name of the conference modifier
|
||
* to transfer to.
|
||
* destination_address_list - Network address list of the
|
||
* conference to transfer to.
|
||
* number_of_destination_nodes - The number of nodes in the list of
|
||
* nodes that should perform the
|
||
* transfer.
|
||
* destination_node_list - The list of nodes that should
|
||
* perform the transfer.
|
||
* password - The password needed to join the
|
||
* new conference.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConferenceAddRequest
|
||
(
|
||
CNetAddrListContainer *network_address_list,
|
||
CUserDataListContainer *user_data_list,
|
||
UserID adding_node,
|
||
TagNumber add_request_tag,
|
||
UserID requesting_node
|
||
)
|
||
{
|
||
BOOL generate_add_indication = FALSE;
|
||
GCCResponseTag add_response_tag;
|
||
|
||
DebugEntry(CConf::ProcessConferenceAddRequest);
|
||
|
||
if (m_pMcsUserObject->GetMyNodeID() == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
if (DoesRequesterHavePrivilege(requesting_node, ADD_PRIVILEGE))
|
||
{
|
||
if ((m_pMcsUserObject->GetMyNodeID() == adding_node) ||
|
||
(adding_node == 0))
|
||
{
|
||
generate_add_indication = TRUE;
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Here we send the add request on to the MCU that is
|
||
** supposed to do the adding.
|
||
*/
|
||
m_pMcsUserObject->ConferenceAddRequest(
|
||
add_request_tag,
|
||
requesting_node,
|
||
adding_node,
|
||
adding_node,
|
||
network_address_list,
|
||
user_data_list);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Send back negative response stating inproper privileges
|
||
m_pMcsUserObject->ConferenceAddResponse(
|
||
add_request_tag,
|
||
requesting_node,
|
||
NULL,
|
||
GCC_RESULT_INVALID_REQUESTER);
|
||
}
|
||
|
||
}
|
||
else if (m_pMcsUserObject->GetMyNodeID() == adding_node)
|
||
{
|
||
/*
|
||
** This is the node that is supposed to get the add indication
|
||
** so send it on.
|
||
*/
|
||
generate_add_indication = TRUE;
|
||
}
|
||
|
||
if (generate_add_indication)
|
||
{
|
||
// First set up the Add Response Tag
|
||
while (1)
|
||
{
|
||
add_response_tag = m_nConfAddResponseTag++;
|
||
|
||
if (0 == m_AddResponseList.Find(add_response_tag))
|
||
break;
|
||
}
|
||
|
||
m_AddResponseList.Append(add_response_tag, add_request_tag);
|
||
|
||
g_pControlSap->ConfAddIndication(m_nConfID,
|
||
add_response_tag,
|
||
network_address_list,
|
||
user_data_list,
|
||
requesting_node);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConferenceAddRequest);
|
||
}
|
||
|
||
|
||
/***************Conductorship Callbacks from User object*******************/
|
||
|
||
|
||
/*
|
||
* void ProcessConductorGrabConfirm ()
|
||
*
|
||
* Private Function Description
|
||
* The routine processes a conductor grab confirm received from the
|
||
* MCSUser object.
|
||
*
|
||
* Formal Parameters:
|
||
* result - This is the result from the grab request.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConductorGrabConfirm ( GCCResult result )
|
||
{
|
||
DebugEntry(CConf::ProcessConductorGrabConfirm);
|
||
|
||
TRACE_OUT(("CConf::ProcessConductorGrabConfirm: result = %d", result));
|
||
|
||
if ((m_eNodeType == TOP_PROVIDER_NODE) ||
|
||
(m_eNodeType == TOP_PROVIDER_AND_CONVENER_NODE))
|
||
{
|
||
#ifdef JASPER
|
||
// Inform the control SAP of the result
|
||
g_pControlSap->ConductorAssignConfirm ( result,
|
||
m_nConfID);
|
||
#endif // JASPER
|
||
|
||
/*
|
||
** If we were successful, we must send a Conductor Assign Indication
|
||
** PDU to every node in the conference to inform them that the
|
||
** conductor has changed.
|
||
*/
|
||
if (result == GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
/*
|
||
** We use NULL for the conductor ID because the conductor can be
|
||
** determined from the sender of the Assign Indication PDU.
|
||
*/
|
||
m_pMcsUserObject->SendConductorAssignIndication(
|
||
m_pMcsUserObject->GetTopNodeID());
|
||
m_nConductorNodeID = m_pMcsUserObject->GetMyNodeID();
|
||
m_fConductorGrantedPermission = TRUE;
|
||
}
|
||
|
||
// Reset the Assign Request Pending flag back to FALSE.
|
||
m_fConductorAssignRequestPending = FALSE;
|
||
}
|
||
else
|
||
{
|
||
if (result == GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
/*
|
||
** If this node is not the Top Provider, we must try to Give the
|
||
** Conductor token to the Top Provider. The Top Provider is used to
|
||
** monitor the use of the conductor token. I the give to the Top
|
||
** Provider is unsuccessful then this node is the new conductor.
|
||
*/
|
||
m_pMcsUserObject->ConductorTokenGive(m_pMcsUserObject->GetTopNodeID());
|
||
}
|
||
else
|
||
{
|
||
#ifdef JASPER
|
||
// Inform the control SAP of the result
|
||
g_pControlSap->ConductorAssignConfirm(result, m_nConfID);
|
||
#endif // JASPER
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConductorGrabConfirm);
|
||
}
|
||
|
||
|
||
/*
|
||
* void ProcessConductorAssignIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conductor assign indication received from
|
||
* the MCSUser object.
|
||
*
|
||
* Formal Parameters:
|
||
* new_conductor_id - This is the node id of the new conductor.
|
||
* sender_id - Node ID of node that sent the indication.
|
||
* Should be the Top Provider.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConductorAssignIndication
|
||
(
|
||
UserID new_conductor_id,
|
||
UserID sender_id
|
||
)
|
||
{
|
||
DebugEntry(CConf::ProcessConductorAssignIndication);
|
||
|
||
if (sender_id == m_pMcsUserObject->GetTopNodeID())
|
||
{
|
||
TRACE_OUT(("CConf: ConductAssignInd: Received from top provider"));
|
||
|
||
// Ignore this indication if the conference is not conductible
|
||
if (m_fConfConductible)
|
||
{
|
||
// Save UserID of the new conductor if not the Top Provider
|
||
if (sender_id != m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
m_nConductorNodeID = new_conductor_id;
|
||
}
|
||
|
||
/*
|
||
** Inform the control SAP and all the enrolled application SAPs
|
||
** that there is a new conductor.
|
||
*/
|
||
TRACE_OUT(("CConf: ConductAssignInd: Send to Control SAP"));
|
||
g_pControlSap->ConductorAssignIndication(m_nConductorNodeID, m_nConfID);
|
||
|
||
/*
|
||
** We iterate on a temporary list to avoid any problems
|
||
** if the application sap leaves during the callback.
|
||
*/
|
||
CAppSap *pAppSap;
|
||
CAppSapList TempList(m_RegisteredAppSapList);
|
||
TempList.Reset();
|
||
while (NULL != (pAppSap = TempList.Iterate()))
|
||
{
|
||
if (DoesSAPHaveEnrolledAPE(pAppSap))
|
||
{
|
||
pAppSap->ConductorAssignIndication(m_nConductorNodeID, m_nConfID);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf:ProcessConductorAssignInd: Conductor Assign sent in non-conductible conference"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf:ProcessConductorAssignInd: Conductor Assign sent from NON-Top Provider"));
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConductorAssignIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* void ProcessConductorReleaseIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conductor release indication received from
|
||
* the MCSUser object.
|
||
*
|
||
* Formal Parameters:
|
||
* sender_id - Node ID of node that sent the indication.
|
||
* Should be the Top Provider or the conductor.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConductorReleaseIndication ( UserID sender_id )
|
||
{
|
||
DebugEntry(CConf::ProcessConductorReleaseIndication);
|
||
|
||
if ((sender_id == m_pMcsUserObject->GetTopNodeID()) ||
|
||
(sender_id == m_nConductorNodeID) ||
|
||
(sender_id == 0))
|
||
{
|
||
// Ignore this indication if the conference is not conductible
|
||
if (m_fConfConductible)
|
||
{
|
||
m_fConductorGrantedPermission = FALSE;
|
||
|
||
// Reset to Non-Conducted mode
|
||
m_nConductorNodeID = 0;
|
||
|
||
/*
|
||
** Inform the control SAP and all the enrolled application SAPs
|
||
** that the conductor was released.
|
||
*/
|
||
g_pControlSap->ConductorReleaseIndication( m_nConfID );
|
||
|
||
/*
|
||
** We iterate on a temporary list to avoid any problems
|
||
** if the application sap leaves during the callback.
|
||
*/
|
||
CAppSap *pAppSap;
|
||
CAppSapList TempList(m_RegisteredAppSapList);
|
||
TempList.Reset();
|
||
while (NULL != (pAppSap = TempList.Iterate()))
|
||
{
|
||
if (DoesSAPHaveEnrolledAPE(pAppSap))
|
||
{
|
||
pAppSap->ConductorReleaseIndication(m_nConfID);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConductorReleaseIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* void ProcessConductorGiveIndication ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conductor give indication received from
|
||
* the MCSUser object.
|
||
*
|
||
* Formal Parameters:
|
||
* giving_node_id - Node ID of node that is givving up
|
||
* conductorship.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConductorGiveIndication ( UserID giving_node_id )
|
||
{
|
||
DebugEntry(CConf::ProcessConductorGiveIndication);
|
||
|
||
// Ignore this indication if the conference is not conductible
|
||
if (m_fConfConductible)
|
||
{
|
||
/*
|
||
** If this node is the Top Provider and node giving conductor ship is
|
||
** not the current Conductor, this node must check to make sure that
|
||
** it is valid for this node to become the Top Conductor. Otherwise,
|
||
** we can assume this is a real give.
|
||
*/
|
||
if ((giving_node_id == m_nConductorNodeID) ||
|
||
(m_pMcsUserObject->GetMyNodeID() != m_pMcsUserObject->GetTopNodeID()))
|
||
{
|
||
// This flag is set when there is an outstanding give.
|
||
m_fConductorGiveResponsePending = TRUE;
|
||
|
||
/*
|
||
** Inform the control SAP.
|
||
*/
|
||
g_pControlSap->ConductorGiveIndication(m_nConfID);
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf: ProcessConductorGiveInd: Send REAL Assign Ind"));
|
||
m_nConductorNodeID = giving_node_id;
|
||
m_pMcsUserObject->SendConductorAssignIndication(m_nConductorNodeID);
|
||
m_pMcsUserObject->ConductorTokenGiveResponse(RESULT_USER_REJECTED);
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConductorGiveIndication);
|
||
}
|
||
|
||
|
||
/*
|
||
* void ProcessConductorGiveConfirm ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conductor give confirm received from
|
||
* the MCSUser object.
|
||
*
|
||
* Formal Parameters:
|
||
* result - This is the result of the give request.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConductorGiveConfirm ( GCCResult result )
|
||
{
|
||
DebugEntry(CConf::ProcessConductorGiveConfirm);
|
||
|
||
TRACE_OUT(("CConf::ProcessConductorGiveConfirm: result = %d", result));
|
||
|
||
// Ignore this indication if the conference is not conductible
|
||
if (m_fConfConductible)
|
||
{
|
||
/*
|
||
** First we must determine if this Give Confirm is from
|
||
** a Give Request to the Top Provider that was associated with an
|
||
** Assign Request. This type of Give Confirm is from the Top Provider.
|
||
** If not, we check to make sure that this is a Give Confirm associated
|
||
** with a give request issued by the Node Controller. Otherwise, we
|
||
** dont process it.
|
||
*/
|
||
if (m_fConductorAssignRequestPending)
|
||
{
|
||
#ifdef JASPER
|
||
/*
|
||
** The proper result is for the Top Provider to reject the give
|
||
** to the Donor User ID that is the new Conductor. This is
|
||
** straight out of the T.124 document.
|
||
*/
|
||
if (result != GCC_RESULT_SUCCESSFUL)
|
||
result = GCC_RESULT_SUCCESSFUL;
|
||
else
|
||
result = GCC_RESULT_UNSPECIFIED_FAILURE;
|
||
|
||
// Inform the control SAP of the result
|
||
g_pControlSap->ConductorAssignConfirm(result, m_nConfID);
|
||
#endif // JASPER
|
||
|
||
m_fConductorAssignRequestPending = FALSE;
|
||
}
|
||
else if (m_nPendingConductorNodeID != 0)
|
||
{
|
||
if (result == GCC_RESULT_SUCCESSFUL)
|
||
m_fConductorGrantedPermission = FALSE;
|
||
|
||
#ifdef JASPER
|
||
g_pControlSap->ConductorGiveConfirm(result, m_nConfID, m_nPendingConductorNodeID);
|
||
#endif // JASPER
|
||
|
||
// Set the pending conductor node ID back to zero.
|
||
m_nPendingConductorNodeID = 0;
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConductorGiveConfirm);
|
||
}
|
||
|
||
|
||
/*
|
||
* void ProcessConductorPermitGrantInd ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conductor permission grant indication received
|
||
* from the MCSUser object.
|
||
*
|
||
* Formal Parameters:
|
||
* permission_grant_indication - This is the PDU data structure
|
||
* associated with the conductor
|
||
* permission grant indication.
|
||
* sender_id - This is the node ID of the node
|
||
* that sent the indication.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConductorPermitGrantInd
|
||
(
|
||
PUserPermissionGrantIndicationInfo permission_grant_indication,
|
||
UserID sender_id
|
||
)
|
||
{
|
||
UINT i;
|
||
|
||
DebugEntry(CConf::ProcessConductorPermitGrantInd);
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
if (sender_id == m_nConductorNodeID)
|
||
{
|
||
// First check to see if we have been given permission
|
||
m_fConductorGrantedPermission = FALSE;
|
||
for (i = 0; i < permission_grant_indication->number_granted; i++)
|
||
{
|
||
if (permission_grant_indication->granted_node_list[i] ==
|
||
m_pMcsUserObject->GetMyNodeID())
|
||
{
|
||
TRACE_OUT(("CConf::ProcessConductorPermitGrantInd: Permission was Granted"));
|
||
m_fConductorGrantedPermission = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
** This indication goes to the control SAP and all the application
|
||
** SAPs.
|
||
*/
|
||
g_pControlSap->ConductorPermitGrantIndication (
|
||
m_nConfID,
|
||
permission_grant_indication->number_granted,
|
||
permission_grant_indication->granted_node_list,
|
||
permission_grant_indication->number_waiting,
|
||
permission_grant_indication->waiting_node_list,
|
||
m_fConductorGrantedPermission);
|
||
|
||
/*
|
||
** We iterate on a temporary list to avoid any problems
|
||
** if the application sap leaves during the callback.
|
||
*/
|
||
CAppSap *pAppSap;
|
||
CAppSapList TempList(m_RegisteredAppSapList);
|
||
TempList.Reset();
|
||
while (NULL != (pAppSap = TempList.Iterate()))
|
||
{
|
||
if (DoesSAPHaveEnrolledAPE(pAppSap))
|
||
{
|
||
pAppSap->ConductorPermitGrantIndication(
|
||
m_nConfID,
|
||
permission_grant_indication->number_granted,
|
||
permission_grant_indication->granted_node_list,
|
||
permission_grant_indication->number_waiting,
|
||
permission_grant_indication->waiting_node_list,
|
||
m_fConductorGrantedPermission);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConductorPermitGrantInd);
|
||
}
|
||
|
||
|
||
/*
|
||
* void ProcessConductorTestConfirm ()
|
||
*
|
||
* Private Function Description
|
||
* This routine processes a conductor test confirm received
|
||
* from the MCSUser object.
|
||
*
|
||
* Formal Parameters:
|
||
* result - This is the result of the conductor test request
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
ProcessConductorTestConfirm ( GCCResult result )
|
||
{
|
||
BOOL conducted_mode;
|
||
CBaseSap *pSap;
|
||
|
||
DebugEntry(CConf::ProcessConductorTestConfirm);
|
||
|
||
if (! m_ConductorTestList.IsEmpty())
|
||
{
|
||
if (result == GCC_RESULT_SUCCESSFUL)
|
||
conducted_mode = TRUE;
|
||
else
|
||
conducted_mode = FALSE;
|
||
|
||
/*
|
||
** Pop the next command target of the list of command targets.
|
||
** Note that all token test request are processed in the order
|
||
** that they were issued so we are gauranteed to send the confirms
|
||
** to the correct target.
|
||
*/
|
||
|
||
pSap = m_ConductorTestList.Get();
|
||
|
||
pSap->ConductorInquireConfirm(m_nConductorNodeID,
|
||
result,
|
||
m_fConductorGrantedPermission,
|
||
conducted_mode,
|
||
m_nConfID);
|
||
}
|
||
|
||
DebugExitVOID(CConf::ProcessConductorTestConfirm);
|
||
}
|
||
|
||
|
||
/*************************************************************************/
|
||
|
||
|
||
/*
|
||
* CConf::InitiateTermination ()
|
||
*
|
||
* Private Function Description
|
||
* This routine informs the owner object that the conference has
|
||
* self terminated. It also directs a disconnect provider request at
|
||
* the parent connection.
|
||
*
|
||
* Formal Parameters:
|
||
* reason - This is the reason for the termination.
|
||
* requesting_node_id - This is the node ID of the node that is
|
||
* making the request,
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
InitiateTermination
|
||
(
|
||
GCCReason reason,
|
||
UserID requesting_node_id
|
||
)
|
||
{
|
||
DebugEntry(CConf::InitiateTermination);
|
||
|
||
if (! m_fTerminationInitiated)
|
||
{
|
||
m_fTerminationInitiated = TRUE;
|
||
|
||
if (m_fConfIsEstablished ||
|
||
(reason == GCC_REASON_DOMAIN_PARAMETERS_UNACCEPTABLE) ||
|
||
m_fConfTerminatePending)
|
||
{
|
||
g_pControlSap->ConfTerminateIndication(m_nConfID, requesting_node_id, reason);
|
||
m_fConfIsEstablished = FALSE;
|
||
}
|
||
|
||
// Disconnect from the MCS parent connection if it exists
|
||
if (m_hParentConnection != NULL)
|
||
{
|
||
g_pMCSIntf->DisconnectProviderRequest(m_hParentConnection);
|
||
m_hParentConnection = NULL;
|
||
}
|
||
|
||
g_pGCCController->ProcessConfTerminated(m_nConfID, reason);
|
||
|
||
/*
|
||
** Here we cleanup the registered application list. If any Application
|
||
** SAPs are still registered we will first send them PermitToEnroll
|
||
** indications revoking the permission to enroll and then we will
|
||
** unregister them (the unregister call takes care of this). First set up
|
||
** a temporary list of the registered applications to iterate on since
|
||
** members of this list will be removed during this process.
|
||
*/
|
||
if (! m_RegisteredAppSapList.IsEmpty())
|
||
{
|
||
CAppSapList TempList(m_RegisteredAppSapList);
|
||
CAppSap *pAppSap;
|
||
TempList.Reset();
|
||
while (NULL != (pAppSap = TempList.Iterate()))
|
||
{
|
||
UnRegisterAppSap(pAppSap);
|
||
}
|
||
}
|
||
}
|
||
|
||
DebugExitVOID(CConf::InitiateTermination);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::GetConferenceNameAndModifier ()
|
||
*
|
||
* Private Function Description
|
||
* This routine returns pointers to the conference name and modifier.
|
||
*
|
||
* Formal Parameters:
|
||
* conference_name - Pointer to structure that holds the conference
|
||
* name.
|
||
* requesting_node_id - This is a pointer to a pointer that holds the
|
||
* conference modifier.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
GetConferenceNameAndModifier
|
||
(
|
||
PGCCConferenceName pConfName,
|
||
PGCCNumericString ppszConfModifier
|
||
)
|
||
{
|
||
pConfName->numeric_string = m_pszConfNumericName;
|
||
pConfName->text_string = m_pwszConfTextName;
|
||
*ppszConfModifier = (GCCNumericString) m_pszConfModifier;
|
||
}
|
||
|
||
|
||
|
||
|
||
/*
|
||
* CAppRosterMgr * CConf::GetAppRosterManager ()
|
||
*
|
||
* Private Function Description
|
||
* This call returns a pointer to the application manager that
|
||
* matches the passed in key. It returns NULL is the application
|
||
* does not exists.
|
||
*
|
||
* Formal Parameters:
|
||
* session_key - This is the session key associated with the
|
||
* application roster manager that is being
|
||
* requested.
|
||
*
|
||
* Return Value
|
||
* A pointer to the appropriate application roster manager.
|
||
* NULL if on does not exists.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
CAppRosterMgr * CConf::
|
||
GetAppRosterManager ( PGCCSessionKey session_key )
|
||
{
|
||
CAppRosterMgr *app_roster_manager = NULL;
|
||
|
||
if (session_key != NULL)
|
||
{
|
||
CAppRosterMgr *lpAppRosterMgr;
|
||
|
||
m_AppRosterMgrList.Reset();
|
||
while (NULL != (lpAppRosterMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
if (lpAppRosterMgr->IsThisYourSessionKey(session_key))
|
||
{
|
||
app_roster_manager = lpAppRosterMgr;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return (app_roster_manager);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::GetNewUserIDTag ()
|
||
*
|
||
* Private Function Description
|
||
* This routine generates a User ID Tag number that is used in a
|
||
* User ID indication sent betweek two connected nodes.
|
||
*
|
||
* Formal Parameters:
|
||
* None.
|
||
*
|
||
* Return Value
|
||
* This is the User ID tag number generated by this routine.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* Zero is not a valid. We initialize the convener user ID tag to
|
||
* zero which is an invalid tag.
|
||
*/
|
||
TagNumber CConf::
|
||
GetNewUserIDTag ( void )
|
||
{
|
||
/*
|
||
** Determine the tag number to associate with the GCC User ID
|
||
** that will be returned after the pending request or confirm.
|
||
*/
|
||
while (1)
|
||
{
|
||
if (++m_nUserIDTagNumber != 0)
|
||
{
|
||
if (m_ConnHdlTagNumberList2.Find(m_nUserIDTagNumber) == 0)
|
||
break;
|
||
}
|
||
}
|
||
|
||
return (m_nUserIDTagNumber);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::DoesRequesterHavePrivilege ()
|
||
*
|
||
* Private Function Description
|
||
* This routine determines if the specified user has the specified
|
||
* privilege.
|
||
*
|
||
* Formal Parameters:
|
||
* requester_id - This is the node ID that is being checked for
|
||
* the specified privilege.
|
||
* privilege - Privilege being checked for.
|
||
*
|
||
* Return Value
|
||
* TRUE - If requester has privilege.
|
||
* FALSE - If requester does NOT have privilege.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
BOOL CConf::
|
||
DoesRequesterHavePrivilege
|
||
(
|
||
UserID requester_id,
|
||
ConferencePrivilegeType privilege
|
||
)
|
||
{
|
||
BOOL rc = FALSE;
|
||
|
||
if (requester_id == m_nConvenerNodeID)
|
||
rc = TRUE;
|
||
else
|
||
{
|
||
/*
|
||
** First check to see if the node is the conductor and a conductor
|
||
** privilege list exists. Next check to see if the conference is in
|
||
** conducted mode and a conducted mode privilege list exists.
|
||
** Else, if not in conducted mode and a Non-Conducted mode privilege
|
||
** list exists use it.
|
||
*/
|
||
if (m_nConductorNodeID == requester_id)
|
||
{
|
||
if (m_pConductorPrivilegeList != NULL)
|
||
{
|
||
rc = m_pConductorPrivilegeList->
|
||
IsPrivilegeAvailable(privilege);
|
||
}
|
||
}
|
||
|
||
if (rc == FALSE)
|
||
{
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
if (m_pConductModePrivilegeList != NULL)
|
||
{
|
||
rc = m_pConductModePrivilegeList->IsPrivilegeAvailable(privilege);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (m_pNonConductModePrivilegeList != NULL)
|
||
{
|
||
rc = m_pNonConductModePrivilegeList->IsPrivilegeAvailable(privilege);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::SendFullRosterRefresh ()
|
||
*
|
||
* Private Function Description
|
||
* When a new node is added to the conference it is the Top Provider's
|
||
* responsiblity to send out a complete refresh of all the rosters
|
||
* including both the conference roster and all the application rosters.
|
||
* That is the responsiblity of the routine.
|
||
*
|
||
* Formal Parameters:
|
||
* None.
|
||
*
|
||
* Return Value
|
||
* GCC_NO_ERROR - No error.
|
||
* GCC_ALLOCATION_FAILURE - A resource error occured.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
GCCError CConf::
|
||
SendFullRosterRefresh ( void )
|
||
{
|
||
GCCError rc;
|
||
GCCPDU gcc_pdu;
|
||
PSetOfApplicationInformation * application_information;
|
||
PSetOfApplicationInformation next_set_of_information;
|
||
|
||
DebugEntry(CConf::SendFullRosterRefresh);
|
||
|
||
/*
|
||
** Start building the roster update indication. Not that this update
|
||
** will include the conference roster as well as all the application
|
||
** rosters.
|
||
*/
|
||
gcc_pdu.choice = INDICATION_CHOSEN;
|
||
|
||
gcc_pdu.u.indication.choice = ROSTER_UPDATE_INDICATION_CHOSEN;
|
||
|
||
gcc_pdu.u.indication.u.roster_update_indication.application_information =
|
||
NULL;
|
||
|
||
gcc_pdu.u.indication.u.roster_update_indication.refresh_is_full = TRUE;
|
||
|
||
// Call on the base class to fill in the PDU structure
|
||
rc = m_pConfRosterMgr->GetFullRosterRefreshPDU (
|
||
&gcc_pdu.u.indication.u.roster_update_indication.node_information);
|
||
|
||
/*
|
||
** If the conference roster get was successful we will iterate through
|
||
** all the application roster managers making the same request for a
|
||
** full refresh. Note that the application_information pointer is updated
|
||
** after every request to an app roster manager. This is because new
|
||
** sets of application information are being allocated everytime this call
|
||
** is made.
|
||
*/
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
CAppRosterMgr *lpAppRosterMgr;
|
||
|
||
application_information = &gcc_pdu.u.indication.u.
|
||
roster_update_indication.application_information;
|
||
|
||
m_AppRosterMgrList.Reset();
|
||
while (NULL != (lpAppRosterMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
next_set_of_information = lpAppRosterMgr->GetFullRosterRefreshPDU (
|
||
application_information,
|
||
&rc);
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
if (next_set_of_information != NULL)
|
||
application_information = &next_set_of_information->next;
|
||
|
||
//
|
||
// LONCHANC: If next_set_of_information is NULL,
|
||
// then application_information is unchanged.
|
||
// This means we effectively ignore this iteration.
|
||
// This is good because we do not lose anything.
|
||
//
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
}
|
||
|
||
/*
|
||
** If no errors have occured up to this point we will go ahead and send
|
||
** out the PDU.
|
||
*/
|
||
if (rc == GCC_NO_ERROR)
|
||
m_pMcsUserObject->RosterUpdateIndication (&gcc_pdu, FALSE);
|
||
|
||
DebugExitINT(CConf::SendFullRosterRefresh, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::UpdateNewConferenceNode ()
|
||
*
|
||
* Private Function Description
|
||
*
|
||
* Formal Parameters:
|
||
* None.
|
||
*
|
||
* Return Value
|
||
* GCC_NO_ERROR - No error.
|
||
* GCC_ALLOCATION_FAILURE - A resource error occured.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
GCCError CConf::
|
||
UpdateNewConferenceNode ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::UpdateNewConferenceNode);
|
||
|
||
// Here we send a full roster refresh for the node that added
|
||
rc = SendFullRosterRefresh ();
|
||
|
||
if (rc == GCC_NO_ERROR)
|
||
{
|
||
/*
|
||
** We must inform the new node of the current conductorship
|
||
** status. Note that we only do this if the conference is
|
||
** conductible and we are the Top Provider.
|
||
*/
|
||
if (m_fConfLocked == CONFERENCE_IS_LOCKED)
|
||
{
|
||
m_pMcsUserObject->SendConferenceLockIndication(
|
||
TRUE, // Indicates uniform send
|
||
0);
|
||
}
|
||
else
|
||
{
|
||
m_pMcsUserObject->SendConferenceUnlockIndication(
|
||
TRUE, // Indicates uniform send
|
||
0);
|
||
}
|
||
|
||
if (m_fConfConductible)
|
||
{
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
m_pMcsUserObject->SendConductorAssignIndication(m_nConductorNodeID);
|
||
}
|
||
else
|
||
m_pMcsUserObject->SendConductorReleaseIndication();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf: UpdateNewConferenceNode: Error sending full refresh"));
|
||
InitiateTermination(GCC_REASON_ERROR_LOW_RESOURCES, 0);
|
||
}
|
||
|
||
DebugExitINT(CConf::UpdateNewConferenceNode, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
** Before we start the disconnect/termination process we must remove all the
|
||
** outstanding invite request from our list and send back associated
|
||
** confirms. Here we go ahead disconnect all connection associated with
|
||
** the invites.
|
||
*/
|
||
void CConf::
|
||
DeleteOutstandingInviteRequests ( void )
|
||
{
|
||
INVITE_REQ_INFO *pInvReqInfo;
|
||
while (NULL != (pInvReqInfo = m_InviteRequestList.Get()))
|
||
{
|
||
DeleteInviteRequest(pInvReqInfo);
|
||
}
|
||
}
|
||
|
||
|
||
void CConf::
|
||
CancelInviteRequest ( ConnectionHandle hInviteReqConn )
|
||
{
|
||
INVITE_REQ_INFO *pInvReqInfo;
|
||
m_InviteRequestList.Reset();
|
||
while (NULL != (pInvReqInfo = m_InviteRequestList.Iterate()))
|
||
{
|
||
if (hInviteReqConn == pInvReqInfo->connection_handle)
|
||
{
|
||
m_InviteRequestList.Remove(pInvReqInfo);
|
||
DeleteInviteRequest(pInvReqInfo);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CConf::
|
||
DeleteInviteRequest ( INVITE_REQ_INFO *pInvReqInfo )
|
||
{
|
||
// Cleanup the connection handle list
|
||
ASSERT(NULL != pInvReqInfo);
|
||
ASSERT(0 != pInvReqInfo->connection_handle);
|
||
m_ConnHandleList.Remove(pInvReqInfo->connection_handle);
|
||
|
||
g_pMCSIntf->DisconnectProviderRequest(pInvReqInfo->connection_handle);
|
||
|
||
// Send the invite confirm
|
||
g_pControlSap->ConfInviteConfirm(m_nConfID,
|
||
NULL,
|
||
GCC_RESULT_INVALID_CONFERENCE,
|
||
pInvReqInfo->connection_handle);
|
||
|
||
// Free up the invite request info structure
|
||
if (NULL != pInvReqInfo->user_data_list)
|
||
{
|
||
pInvReqInfo->user_data_list->Release();
|
||
}
|
||
delete pInvReqInfo;
|
||
}
|
||
|
||
|
||
void CConf::
|
||
ProcessConfJoinResponse
|
||
(
|
||
PUserJoinResponseInfo join_response_info
|
||
)
|
||
{
|
||
BOOL_PTR bptr;
|
||
|
||
if (NULL != (bptr = m_JoinRespNamePresentConnHdlList2.Remove(join_response_info->connection_handle)))
|
||
{
|
||
ConfJoinIndResponse (
|
||
(ConnectionHandle)join_response_info->connection_handle,
|
||
join_response_info->password_challenge,
|
||
join_response_info->user_data_list,
|
||
(bptr != FALSE_PTR),
|
||
FALSE,
|
||
join_response_info->result);
|
||
}
|
||
}
|
||
|
||
|
||
void CConf::
|
||
ProcessAppInvokeIndication
|
||
(
|
||
CInvokeSpecifierListContainer *pInvokeList,
|
||
UserID uidInvoker
|
||
)
|
||
{
|
||
/*
|
||
** Here we pass the invoke along to all the enrolled application
|
||
** SAPs as well as the control SAP.
|
||
*/
|
||
g_pControlSap->AppInvokeIndication(m_nConfID, pInvokeList, uidInvoker);
|
||
|
||
/*
|
||
** We iterate on a temporary list to avoid any problems
|
||
** if the application sap leaves during the callback.
|
||
*/
|
||
CAppSap *pAppSap;
|
||
CAppSapList TempList(m_RegisteredAppSapList);
|
||
TempList.Reset();
|
||
while (NULL != (pAppSap = TempList.Iterate()))
|
||
{
|
||
if (DoesSAPHaveEnrolledAPE(pAppSap))
|
||
{
|
||
pAppSap->AppInvokeIndication(m_nConfID, pInvokeList, uidInvoker);
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifdef JASPER
|
||
void CConf::
|
||
ProcessConductorPermitAskIndication
|
||
(
|
||
PPermitAskIndicationInfo indication_info
|
||
)
|
||
{
|
||
// Ignore this indication if the conference is not conductible
|
||
if (m_fConfConductible &&
|
||
(m_nConductorNodeID == m_pMcsUserObject->GetMyNodeID()))
|
||
{
|
||
g_pControlSap->ConductorPermitAskIndication(
|
||
m_nConfID,
|
||
indication_info->permission_is_granted,
|
||
indication_info->sender_id);
|
||
}
|
||
}
|
||
#endif // JASPER
|
||
|
||
|
||
void CConf::
|
||
ProcessConfAddResponse
|
||
(
|
||
PAddResponseInfo add_response_info
|
||
)
|
||
{
|
||
CNetAddrListContainer *network_address_list;
|
||
|
||
if (NULL != (network_address_list = m_AddRequestList.Remove(add_response_info->add_request_tag)))
|
||
{
|
||
g_pControlSap->ConfAddConfirm(
|
||
m_nConfID,
|
||
network_address_list,
|
||
add_response_info->user_data_list,
|
||
add_response_info->result);
|
||
|
||
// Unlock and remove the net address list
|
||
network_address_list->UnLockNetworkAddressList();
|
||
}
|
||
}
|
||
|
||
|
||
void CConf::
|
||
ConfRosterReportIndication ( CConfRosterMsg * pMsg )
|
||
{
|
||
// First send the update to the Control Sap.
|
||
g_pControlSap->ConfRosterReportIndication(m_nConfID, pMsg);
|
||
|
||
// Next send the update to all the Enrolled Application Saps
|
||
|
||
#if 0 // LONCHANC: app sap does not support conf roster report indication
|
||
/*
|
||
** We iterate on a temporary list to avoid any problems
|
||
** if the application sap leaves during the callback.
|
||
*/
|
||
CAppSap *pAppSap;
|
||
CAppSapList TempList(m_RegisteredAppSapList);
|
||
TempList.Reset();
|
||
while (NULL != (pAppSap = TempList.Iterate()))
|
||
{
|
||
if (DoesSAPHaveEnrolledAPE(pAppSap))
|
||
{
|
||
pAppSap->ConfRosterReportIndication(m_nConfID, pMsg);
|
||
}
|
||
}
|
||
#endif // 0
|
||
}
|
||
|
||
|
||
|
||
int KeyCompare(const struct Key *key1, const struct Key *key2)
|
||
{
|
||
if (key1->choice != key2->choice)
|
||
return 1;
|
||
|
||
switch (key1->choice) {
|
||
case object_chosen:
|
||
return ASN1objectidentifier_cmp((struct ASN1objectidentifier_s **) &key1->u.object,
|
||
(struct ASN1objectidentifier_s **) &key2->u.object);
|
||
|
||
case h221_non_standard_chosen:
|
||
if (key1->u.h221_non_standard.length != key2->u.h221_non_standard.length)
|
||
return 1;
|
||
return memcmp(&key1->u.h221_non_standard.value,
|
||
&key2->u.h221_non_standard.value,
|
||
key1->u.h221_non_standard.length);
|
||
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
BOOL CConf::
|
||
DoesRosterPDUContainApplet(PGCCPDU roster_update,
|
||
const struct Key *app_proto_key, BOOL refreshonly)
|
||
{
|
||
BOOL rc = FALSE;
|
||
PSetOfApplicationInformation set_of_application_info;
|
||
ASN1choice_t choice;
|
||
PSessionKey session_key;
|
||
|
||
DebugEntry(CConf::DoesRosterPDUContainApplet);
|
||
|
||
set_of_application_info = roster_update->u.indication.u.
|
||
roster_update_indication.application_information;
|
||
|
||
|
||
while (set_of_application_info != NULL)
|
||
{
|
||
choice = set_of_application_info->value.application_record_list.choice;
|
||
session_key = &set_of_application_info->value.session_key;
|
||
|
||
if (refreshonly && (choice != application_record_refresh_chosen))
|
||
continue;
|
||
if (!refreshonly && (choice == application_no_change_chosen))
|
||
continue;
|
||
|
||
if (0 == KeyCompare(&session_key->application_protocol_key,
|
||
app_proto_key))
|
||
{
|
||
rc = TRUE;
|
||
break;
|
||
}
|
||
set_of_application_info = set_of_application_info->next;
|
||
}
|
||
|
||
DebugExitINT(CConf::DoesRosterPDUContainApplet, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
UINT HexaStringToUINT(LPCTSTR pcszString)
|
||
{
|
||
ASSERT(pcszString);
|
||
UINT uRet = 0;
|
||
LPTSTR pszStr = (LPTSTR) pcszString;
|
||
while (_T('\0') != pszStr[0])
|
||
{
|
||
if ((pszStr[0] >= _T('0')) && (pszStr[0] <= _T('9')))
|
||
{
|
||
uRet = (16 * uRet) + (BYTE) (pszStr[0] - _T('0'));
|
||
}
|
||
else if ((pszStr[0] >= _T('a')) && (pszStr[0] <= _T('f')))
|
||
{
|
||
uRet = (16 * uRet) + (BYTE) (pszStr[0] - _T('a') + 10);
|
||
}
|
||
else if ((pszStr[0] >= _T('A')) && (pszStr[0] <= _T('F')))
|
||
{
|
||
uRet = (16 * uRet) + (BYTE) (pszStr[0] - _T('A') + 10);
|
||
}
|
||
else
|
||
ASSERT(0);
|
||
|
||
pszStr++; // NOTE: DBCS characters are not allowed!
|
||
}
|
||
return uRet;
|
||
}
|
||
|
||
|
||
void CConf::AddNodeVersion(UserID NodeId, NodeRecord *pNodeRecord)
|
||
{
|
||
PSetOfUserData set_of_user_data;
|
||
ASN1octetstring_t user_data;
|
||
ASN1octet_t *currpos;
|
||
TCHAR szVersion[256];
|
||
|
||
if (pNodeRecord->bit_mask&RECORD_USER_DATA_PRESENT)
|
||
{
|
||
set_of_user_data = pNodeRecord->record_user_data;
|
||
while (set_of_user_data)
|
||
{
|
||
if (set_of_user_data->user_data_element.bit_mask & USER_DATA_FIELD_PRESENT)
|
||
{
|
||
user_data = set_of_user_data->user_data_element.user_data_field;
|
||
// Looking for the octet string L"VER:"
|
||
currpos = user_data.value;
|
||
while (currpos + sizeof(L"VER:") < user_data.value + user_data.length)
|
||
{
|
||
if (!memcmp(currpos, L"VER:", 8))
|
||
{
|
||
break;
|
||
}
|
||
currpos++;
|
||
}
|
||
if (currpos + sizeof(L"VER:") < user_data.value + user_data.length)
|
||
{ // found
|
||
WideCharToMultiByte(CP_ACP, 0, (const unsigned short*)(currpos+8),
|
||
4 /* only need version num, "0404" */,
|
||
szVersion, 256, 0, 0);
|
||
szVersion[4] = '\0';
|
||
DWORD dwVer = HexaStringToUINT(szVersion);
|
||
m_NodeVersionList2.Append(NodeId, dwVer);
|
||
WARNING_OUT(("Insert version %x0x for node %d.\n", dwVer, NodeId));
|
||
}
|
||
}
|
||
set_of_user_data = set_of_user_data->next;
|
||
}
|
||
}
|
||
}
|
||
|
||
GCCError CConf::UpdateNodeVersionList(PGCCPDU roster_update,
|
||
GCCNodeID sender_id)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
NodeRecordList node_record_list;
|
||
ASN1choice_t choice;
|
||
PSetOfNodeRecordRefreshes set_of_node_refresh;
|
||
PSetOfNodeRecordUpdates set_of_node_update;
|
||
UserID node_id;
|
||
NodeRecord *pNodeRecord;
|
||
|
||
node_record_list = roster_update->u.indication.u.roster_update_indication.
|
||
node_information.node_record_list;
|
||
|
||
switch(node_record_list.choice)
|
||
{
|
||
case node_no_change_chosen:
|
||
break;
|
||
|
||
case node_record_refresh_chosen:
|
||
set_of_node_refresh = node_record_list.u.node_record_refresh;
|
||
while (set_of_node_refresh)
|
||
{
|
||
node_id = set_of_node_refresh->value.node_id;
|
||
pNodeRecord = &set_of_node_refresh->value.node_record;
|
||
AddNodeVersion(node_id, pNodeRecord);
|
||
set_of_node_refresh = set_of_node_refresh->next;
|
||
}
|
||
break;
|
||
|
||
case node_record_update_chosen:
|
||
set_of_node_update = node_record_list.u.node_record_update;
|
||
while (set_of_node_update)
|
||
{
|
||
node_id = set_of_node_update->value.node_id;
|
||
switch(set_of_node_update->value.node_update.choice)
|
||
{
|
||
case node_remove_record_chosen:
|
||
m_NodeVersionList2.Remove(node_id);
|
||
break;
|
||
|
||
case node_add_record_chosen:
|
||
pNodeRecord = &set_of_node_update->value.node_update.u.node_add_record;
|
||
AddNodeVersion(node_id, pNodeRecord);
|
||
break;
|
||
}
|
||
|
||
set_of_node_update = set_of_node_update->next;
|
||
}
|
||
break;
|
||
}
|
||
return rc;
|
||
}
|
||
|
||
|
||
BOOL CConf::HasNM2xNode(void)
|
||
{
|
||
DWORD dwVer;
|
||
m_NodeVersionList2.Reset();
|
||
while (NULL != (dwVer = m_NodeVersionList2.Iterate()))
|
||
{
|
||
if (dwVer < 0x0404)
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
DWORD WINAPI T120_GetNodeVersion(GCCConfID ConfId, GCCNodeID NodeId)
|
||
{
|
||
CConf *pConf = g_pGCCController->GetConfObject(ConfId);
|
||
DWORD version;
|
||
if (pConf)
|
||
{
|
||
version = pConf->GetNodeVersion(NodeId);
|
||
return version;
|
||
}
|
||
return 0;
|
||
}
|
||
|