3093 lines
85 KiB
C++
3093 lines
85 KiB
C++
#include "precomp.h"
|
||
DEBUG_FILEZONE(ZONE_T120_GCCNC);
|
||
/*
|
||
* conf.cpp
|
||
*
|
||
* Copyright (c) 1995 by DataBeam Corporation, Lexington, KY
|
||
*
|
||
* Abstract:
|
||
* This is 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.
|
||
*
|
||
* FOR A MORE DETAILED EXPLANATION OF THIS CLASS SEE THE INTERFACE FILE.
|
||
*
|
||
* Portable:
|
||
* Yes
|
||
*
|
||
* Private Instance Variables
|
||
* m_JoinRespNamePresentConnHdlList2
|
||
* This list keeps up with outstanding joins at an intermediate node.
|
||
* Enrolled_App_List
|
||
* This list keeps up with all the enrolled applications.
|
||
* m_ConnHandleList
|
||
* This list keeps up with all the child node connection handles.
|
||
* m_ConnHdlTagNumberList2
|
||
* This list keeps up with all the outstanding user ID Tag numbers.
|
||
* m_EjectedNodeConfirmList
|
||
* This list keeps up with all the nodes that have been ejected but
|
||
* have yet to disconnect. Used to disconnect any misbehaving apps.
|
||
* m_pMcsUserObject
|
||
* Holds a pointer to the MCSUser object owned by this conference.
|
||
* m_pszConfNumericName
|
||
* Holds the numeric conference name.
|
||
* m_pwszConfTextName
|
||
* Holds a pointer to a unicode string object that contains the text
|
||
* conference name. NULL if empty.
|
||
* m_pszConfModifier
|
||
* Holds a pointer to the conference modifier. NULL if empty.
|
||
* m_pszRemoteModifier
|
||
* Holds a pointer to the remote modifier. Only used in Join Confirms.
|
||
* m_nConfID
|
||
* Holds the conference ID associated with this conference object.
|
||
* m_fConfLocked
|
||
* Flag that indicates if the conference is locked.
|
||
* m_fConfListed
|
||
* Flag that indicates if the conference is listed.
|
||
* m_fConfConductible
|
||
* Flag that indicates if the conference is conductible.
|
||
* m_fClearPassword
|
||
* Flag that indicates if password in the clear is used.
|
||
* m_nConvenerNodeID
|
||
* Holds the MCS user ID of the convener. Zero if convener has left.
|
||
* m_eTerminationMethod
|
||
* Holds the enumeration that defines the termination method.
|
||
* m_pDomainParameters
|
||
* Holds the domain parameters that are returned in a number
|
||
* of confirms.
|
||
* m_nUserIDTagNumber
|
||
* The tag number that must be included when sending this nodes user ID
|
||
* back to a connected node.
|
||
* m_nConvenerUserIDTagNumber
|
||
* Used to uniquely mark the convener when it is rejoining a
|
||
* conference.
|
||
* m_nParentIDTagNumber
|
||
* Used to uniquely mark the parent user ID for an invited node.
|
||
* m_eNodeType
|
||
* Holds the enumerated Node Type for this particular node.
|
||
* m_hParentConnection
|
||
* Holds the parent logical connection handle.
|
||
* m_hConvenerConnection
|
||
* Holds the convener connection handle.
|
||
* m_fConfIsEstablished
|
||
* Flag which is set to TRUE when the confernce is completely
|
||
* established and ready for enrolls and announces.
|
||
* m_fConfDisconnectPending
|
||
* Flag which is set to TRUE when a disconnect has been issued but
|
||
* the conference is waiting for subordinate nodes to disconnect.
|
||
* m_fConfTerminatePending
|
||
* Flag which is set to TRUE when a terminate has been issued but
|
||
* the conference is waiting for subordinate nodes to disconnect.
|
||
* m_eConfTerminateReason
|
||
* Maintains the terminate reason for delivery in the indication.
|
||
* m_pConfTerminateAlarm
|
||
* Alarm that is used to force automatic termination when
|
||
* subordinate nodes will not disconnect.
|
||
* m_pConfStartupAlarm
|
||
* Alarm used to hold back the flush of the first roster update
|
||
* indication until all the APEs that wish to enroll have had time
|
||
* to enroll.
|
||
* m_pConductorPrivilegeList
|
||
* Holds a pointer to the conductor privilege list object.
|
||
* m_pConductModePrivilegeList
|
||
* Holds a pointer to the conducted mode privilege list object.
|
||
* m_pNonConductModePrivilegeList
|
||
* Holds a pointer to the non-conducted mode privilege list object.
|
||
* m_pwszConfDescription
|
||
* Holds a pointer to a unicode string which holds the conference
|
||
* description.
|
||
* m_pNetworkAddressList
|
||
* Holds a pointer to an object that contains all the local network
|
||
* addresses.
|
||
* m_pUserDataList
|
||
* Holds a pointer to a user data object needed to deliver an
|
||
* asynchronus confirm message.
|
||
* m_nConfAddRequestTagNumber
|
||
* This instance variable is used to generate the add request tag that
|
||
* is returned in an add response.
|
||
* m_nConfAddResponseTag
|
||
* This instance variable is used to generate a response tag that is
|
||
* passed in an add indication and returned in an add response.
|
||
* m_AddRequestList
|
||
* List that keeps up with all the outstanding add request tags.
|
||
* m_AddResponseList
|
||
* List that keeps up with all the outstanding add response tags.
|
||
* m_pConfRosterMgr
|
||
* Pointer to the Conference Roster manager.
|
||
* m_AppRosterMgrList
|
||
* List which holds pointers to all ofthe Application Roster managers.
|
||
* m_pAppRegistry
|
||
* Pointer to the Application Registry object used by this conference.
|
||
* m_InviteRequestList
|
||
* List which keeps up with the info associated with all of the
|
||
* outstanding invite request. Used for cleanup when the invited
|
||
* node never responds.
|
||
* m_nConductorNodeID
|
||
* The MCS user ID associated with the conducting node. Zero if the
|
||
* conference is not in conducted mode.
|
||
* m_nPendingConductorNodeID
|
||
* Used to keep up with the new conductor node ID when conductorship
|
||
* is being passed from one node to another.
|
||
* m_fConductorGrantedPermission
|
||
* Flag which when TRUE specifies that this node has conductor granted
|
||
* permission.
|
||
* m_ConductorTestList
|
||
* List that is used to keep up with all the command targets that have
|
||
* issued conductor inquire request.
|
||
* m_fConductorGiveResponsePending
|
||
* Flag that states if this node is waiting on a conductor give
|
||
* response.
|
||
* m_fConductorAssignRequestPending
|
||
* Flag that states if this node is waiting to here back from an
|
||
* assign request.
|
||
* APE_Enitity_ID
|
||
* This is a counter used to generate application enityt ids.
|
||
*
|
||
* Caveats:
|
||
* Note that the conference object is now split into two seperate files
|
||
* to prevent text segment problems. This file contains the constructors
|
||
* and all the entry points for the Owner Object.
|
||
*
|
||
* Author:
|
||
* blp
|
||
*/
|
||
|
||
#include "conf.h"
|
||
#include "gcontrol.h"
|
||
#include "translat.h"
|
||
#include "ogcccode.h"
|
||
|
||
#ifdef _DEBUG
|
||
#define STARTUP_TIMER_DURATION 10000 // Ten second startup time
|
||
#else
|
||
#define STARTUP_TIMER_DURATION 2000 // Two second startup time
|
||
#endif
|
||
|
||
|
||
extern MCSDLLInterface *g_pMCSIntf;
|
||
|
||
/*
|
||
* 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;
|
||
|
||
/*
|
||
* CConf::CConf ()
|
||
*
|
||
* Public Function Description
|
||
* When pConfSpecParams != NULL
|
||
* This is the conference constructor. It is responsible for
|
||
* initializing all the instance variables used by this class.
|
||
* It also creates the MCS domain based on the conference id.
|
||
* Fatal errors are returned from this constructor in the
|
||
* return value. Note that this constructor is used when the
|
||
* Conference specification parameters such as termination
|
||
* method or known in advance of conference creation. This is
|
||
* the case for a CONVENOR node and a TOP PROVIDER. It is not
|
||
* used for joining nodes.
|
||
*
|
||
* When pConfSpecParams == NULL
|
||
* This is the conference constructor. It is responsible for
|
||
* initializing all the instance variables used by this class.
|
||
* It also creates the MCS domain based on the conference id.
|
||
* Fatal errors are returned from this constructor in the
|
||
* return value. Note that this constructor is used by nodes that
|
||
* do not know the Conference specification parameters such as
|
||
* termination method in advance of conference creation. This is
|
||
* the case for joining nodes.
|
||
*/
|
||
CConf::
|
||
CConf
|
||
(
|
||
PGCCConferenceName pConfName,
|
||
GCCNumericString pszConfModifier,
|
||
GCCConfID nConfID,
|
||
CONF_SPEC_PARAMS *pConfSpecParams,
|
||
UINT cNetworkAddresses,
|
||
PGCCNetworkAddress *pLocalNetworkAddress,
|
||
PGCCError pRetCode
|
||
)
|
||
:
|
||
CRefCount(MAKE_STAMP_ID('C','o','n','f')),
|
||
m_RegisteredAppSapList(DESIRED_MAX_APP_SAP_ITEMS),
|
||
m_EnrolledApeEidList2(DESIRED_MAX_APP_SAP_ITEMS),
|
||
m_ConnHdlTagNumberList2(DESIRED_MAX_CONN_HANDLES),
|
||
m_JoinRespNamePresentConnHdlList2(CLIST_DEFAULT_MAX_ITEMS),
|
||
m_InviteRequestList(CLIST_DEFAULT_MAX_ITEMS),
|
||
m_ConnHandleList(DESIRED_MAX_CONN_HANDLES),
|
||
m_EjectedNodeConfirmList(CLIST_DEFAULT_MAX_ITEMS),
|
||
m_AddRequestList(CLIST_DEFAULT_MAX_ITEMS),
|
||
m_AddResponseList(CLIST_DEFAULT_MAX_ITEMS),
|
||
m_NodeVersionList2(CLIST_DEFAULT_MAX_ITEMS),
|
||
m_cEnrollRequests(0),
|
||
m_fFirstAppRosterSent(FALSE),
|
||
m_nConfID(nConfID),
|
||
m_pMcsUserObject(NULL),
|
||
m_pDomainParameters(NULL),
|
||
m_pUserDataList(NULL),
|
||
m_pszRemoteModifier(NULL),
|
||
m_pConfRosterMgr(NULL),
|
||
m_pAppRegistry(NULL),
|
||
m_nConductorNodeID(0),
|
||
m_nPendingConductorNodeID(0),
|
||
m_fConductorGrantedPermission(FALSE),
|
||
m_fConductorGiveResponsePending(FALSE),
|
||
m_fConductorAssignRequestPending(FALSE),
|
||
m_hParentConnection(0),
|
||
m_hConvenerConnection(0),
|
||
m_pConfTerminateAlarm(NULL),
|
||
m_nUserIDTagNumber(0),
|
||
m_nConfAddRequestTagNumber(0),
|
||
m_nConfAddResponseTag(0),
|
||
m_nConvenerNodeID(0),
|
||
m_nConvenerUserIDTagNumber(0),
|
||
m_nAPEEntityID(0),
|
||
m_pwszConfTextName(NULL),
|
||
m_pszConfModifier(NULL),
|
||
m_pConductorPrivilegeList(NULL),
|
||
m_pConductModePrivilegeList(NULL),
|
||
m_pNonConductModePrivilegeList(NULL),
|
||
m_pwszConfDescription(NULL),
|
||
m_pNetworkAddressList(NULL),
|
||
/* This variable transitions to TRUE when the conference has completely
|
||
** stabilized. Once it is set to TRUE applications may enroll with the
|
||
** conference. */
|
||
m_fConfIsEstablished(FALSE),
|
||
/* This variable is transitioned to TRUE if the node that is
|
||
** disconnected is connected to child nodes. */
|
||
m_fConfDisconnectPending(FALSE),
|
||
/* This variable is transitioned to TRUE if a valid Terminate request
|
||
** is processed. */
|
||
m_fConfTerminatePending(FALSE),
|
||
/* This variable is set to TRUE if InitiateTermination is called once */
|
||
m_fTerminationInitiated(FALSE),
|
||
m_fSecure(FALSE),
|
||
m_fWBEnrolled(FALSE),
|
||
m_fFTEnrolled(FALSE),
|
||
m_fChatEnrolled(FALSE)
|
||
{
|
||
GCCError rc = GCC_ALLOCATION_FAILURE;
|
||
|
||
DebugEntry(CConf::CConf);
|
||
|
||
// Conference Specification
|
||
if (NULL != pConfSpecParams)
|
||
{
|
||
m_fClearPassword = pConfSpecParams->fClearPassword;
|
||
m_fConfLocked = pConfSpecParams->fConfLocked;
|
||
m_fConfListed = pConfSpecParams->fConfListed;
|
||
m_fConfConductible = pConfSpecParams->fConfConductable;
|
||
m_eTerminationMethod = pConfSpecParams->eTerminationMethod;
|
||
}
|
||
|
||
// m_pConfStartupAlarm = NULL;
|
||
DBG_SAVE_FILE_LINE
|
||
m_pConfStartupAlarm = new Alarm(STARTUP_TIMER_DURATION);
|
||
if (NULL == m_pConfStartupAlarm)
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating startup alarm"));
|
||
goto MyExit;
|
||
}
|
||
|
||
// Save the numeric conference name.
|
||
if (NULL != pConfName->numeric_string)
|
||
{
|
||
if (NULL == (m_pszConfNumericName = ::My_strdupA(pConfName->numeric_string)))
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating conf numeric name"));
|
||
goto MyExit;
|
||
}
|
||
TRACE_OUT(("CConf::CConf: m_strConfNumericName = %s", m_pszConfNumericName));
|
||
}
|
||
else
|
||
{
|
||
m_pszConfNumericName = NULL;
|
||
if (NULL != pConfSpecParams)
|
||
{
|
||
//
|
||
// LONCHANC: It is an error for top-provider.
|
||
//
|
||
ERROR_OUT(("CConf::CConf: Error: Numeric Name not present"));
|
||
rc = GCC_INVALID_CONFERENCE_NAME;
|
||
goto MyExit;
|
||
}
|
||
//
|
||
// LONCHANC: It is not an error for joining node.
|
||
//
|
||
}
|
||
|
||
// Save the text conference name if one exists
|
||
if (NULL != pConfName->text_string)
|
||
{
|
||
if (NULL == (m_pwszConfTextName = ::My_strdupW(pConfName->text_string)))
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating unicode string"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
// Save the conference modifier if one exists
|
||
if (NULL != pszConfModifier)
|
||
{
|
||
if (NULL == (m_pszConfModifier = ::My_strdupA(pszConfModifier)))
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating conf modifier"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::CConf: Conference_Modifier = %s", m_pszConfModifier));
|
||
}
|
||
}
|
||
|
||
// Set up the privilege list as needed
|
||
if (NULL != pConfSpecParams)
|
||
{
|
||
if (NULL != pConfSpecParams->pConductPrivilege)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pConductorPrivilegeList = new PrivilegeListData(pConfSpecParams->pConductPrivilege);
|
||
if (NULL == m_pConductorPrivilegeList)
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating conductor privilege list"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
if (NULL != pConfSpecParams->pConductModePrivilege)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pConductModePrivilegeList = new PrivilegeListData(pConfSpecParams->pConductModePrivilege);
|
||
if (NULL == m_pConductModePrivilegeList)
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating conduct mode privilege list"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
if (NULL != pConfSpecParams->pNonConductPrivilege)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pNonConductModePrivilegeList = new PrivilegeListData(pConfSpecParams->pNonConductPrivilege);
|
||
if (NULL == m_pNonConductModePrivilegeList)
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating non-conduct mode privilege list"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
if (NULL != pConfSpecParams->pwszConfDescriptor)
|
||
{
|
||
if (NULL == (m_pwszConfDescription =
|
||
::My_strdupW(pConfSpecParams->pwszConfDescriptor)))
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating conf descriptor"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Save the network address(es)
|
||
if (0 != cNetworkAddresses)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pNetworkAddressList = new CNetAddrListContainer(cNetworkAddresses, pLocalNetworkAddress, &rc);
|
||
if (NULL == m_pNetworkAddressList || GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error allocating network address list"));
|
||
rc = GCC_ALLOCATION_FAILURE; // rc could be a different value
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
|
||
/*
|
||
** Create the Domain based on the conference name that was
|
||
** passed in.
|
||
*/
|
||
if (MCS_NO_ERROR != g_pMCSIntf->CreateDomain(&m_nConfID))
|
||
{
|
||
ERROR_OUT(("CConf::CConf: Error creating domain"));
|
||
rc = GCC_FAILURE_CREATING_DOMAIN;
|
||
goto MyExit;
|
||
}
|
||
|
||
rc = GCC_NO_ERROR;
|
||
|
||
MyExit:
|
||
|
||
*pRetCode = rc;
|
||
|
||
DebugExitINT(CConf::CConf, rc);
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::~CConf ()
|
||
*
|
||
* Public Function Description
|
||
* This is the conference destructor. It is responsible for
|
||
* deleting the User Attachment and freeing up any outstanding
|
||
* resources used by the conference class. It also calls
|
||
* MCS Disconnect Provider to disconnect fron all its connections
|
||
* including both parent and child connections. In addition, it
|
||
* unregisters its command target from the controller and application
|
||
* SAPs and deletes the MCS domain it is associated with.
|
||
*
|
||
* Caveats
|
||
* none
|
||
*/
|
||
CConf::
|
||
~CConf ( void )
|
||
{
|
||
ConnectionHandle nConnHdl;
|
||
//CAppRosterMgr *lpAppRosterMgr;
|
||
ENROLLED_APE_INFO *lpEnrAPEInfo;
|
||
//CAppSap *pAppSap;
|
||
|
||
DebugEntry(CConf::~CConf);
|
||
|
||
// Delete the terminate alarm if it exists
|
||
delete m_pConfTerminateAlarm;
|
||
|
||
// Delete the startup alarm if it exists
|
||
delete m_pConfStartupAlarm;
|
||
|
||
// Delete Conference Roster Managers
|
||
if (NULL != m_pConfRosterMgr)
|
||
{
|
||
m_pConfRosterMgr->Release();
|
||
}
|
||
|
||
// Delete Application Roster Managers
|
||
m_AppRosterMgrList.DeleteList();
|
||
|
||
// Delete the application registry
|
||
if (NULL != m_pAppRegistry)
|
||
{
|
||
m_pAppRegistry->Release();
|
||
}
|
||
|
||
// Delete the text conference name if it exist
|
||
delete m_pszConfNumericName;
|
||
delete m_pwszConfTextName;
|
||
|
||
// Delete the conference modifier if it exist
|
||
delete m_pszConfModifier;
|
||
|
||
// Delete the remote modifier if it exist
|
||
delete m_pszRemoteModifier;
|
||
|
||
/*
|
||
** The privilege list are not directly deleted here instead Free is called
|
||
** to prevent the list from being deleted in the case where it has been
|
||
** locked outside the conference object.
|
||
*/
|
||
|
||
// Delete all the privilege list (Free is needed incase the list
|
||
delete m_pConductorPrivilegeList;
|
||
delete m_pConductModePrivilegeList;
|
||
delete m_pNonConductModePrivilegeList;
|
||
|
||
// Delete the conference descriptor
|
||
delete m_pwszConfDescription;
|
||
|
||
// Delete the network address list
|
||
if (NULL != m_pNetworkAddressList)
|
||
{
|
||
m_pNetworkAddressList->Release();
|
||
}
|
||
|
||
if (NULL != m_pUserDataList)
|
||
{
|
||
m_pUserDataList->Release();
|
||
}
|
||
|
||
// Delete the Domain Parameters if they exist
|
||
delete m_pDomainParameters;
|
||
|
||
// Delete the User Attachment object if they exist
|
||
if (NULL != m_pMcsUserObject)
|
||
{
|
||
m_pMcsUserObject->Release();
|
||
}
|
||
|
||
// Disconnect from the MCS parent connection
|
||
if (m_hParentConnection != NULL)
|
||
{
|
||
g_pMCSIntf->DisconnectProviderRequest(m_hParentConnection);
|
||
}
|
||
|
||
// Disconnect from all MCS child connections
|
||
m_ConnHandleList.Reset();
|
||
while (0 != (nConnHdl = m_ConnHandleList.Iterate()))
|
||
{
|
||
g_pMCSIntf->DisconnectProviderRequest(nConnHdl);
|
||
}
|
||
|
||
// Delete the MCS domain
|
||
g_pMCSIntf->DeleteDomain(&m_nConfID);
|
||
|
||
// Cleanup up the m_EnrolledApeEidList2
|
||
m_EnrolledApeEidList2.Reset();
|
||
while (NULL != (lpEnrAPEInfo = m_EnrolledApeEidList2.Iterate()))
|
||
{
|
||
if (NULL != lpEnrAPEInfo->session_key)
|
||
{
|
||
lpEnrAPEInfo->session_key->Release();
|
||
}
|
||
delete lpEnrAPEInfo;
|
||
}
|
||
|
||
DebugExitVOID(CConf::~CConf);
|
||
}
|
||
|
||
|
||
/*
|
||
** Non-CommandTarget Calls. Initiated from the Owner Object. Note that
|
||
** all calls received from the owner object are preceeded by GCC.
|
||
*/
|
||
|
||
|
||
/*
|
||
* CConf::ConfCreateRequest()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a
|
||
* ConferenceCreateRequest primitive needs to be processed.
|
||
* If the calling address equals the called address then an
|
||
* empty conference is created at this node (this node will
|
||
* then be both the convenor and the top provider).
|
||
*
|
||
* Caveats
|
||
* All errors should be handled directly by the calling application.
|
||
* This includes deletion of the conference object.
|
||
*/
|
||
GCCError CConf::
|
||
ConfCreateRequest
|
||
(
|
||
TransportAddress calling_address,
|
||
TransportAddress called_address,
|
||
BOOL fSecure,
|
||
CPassword *convener_password,
|
||
CPassword *password,
|
||
LPWSTR pwszCallerID,
|
||
PDomainParameters domain_parameters,
|
||
CUserDataListContainer *user_data_list,
|
||
PConnectionHandle connection_handle
|
||
)
|
||
{
|
||
GCCError rc = GCC_ALLOCATION_FAILURE;
|
||
ConnectGCCPDU connect_pdu;
|
||
LPBYTE encoded_pdu;
|
||
UINT encoded_pdu_length;
|
||
MCSError mcs_error;
|
||
|
||
DebugEntry(CConf::ConfCreateRequest);
|
||
|
||
/*
|
||
** First make a copy of the new domain parameters if they exists. These
|
||
** will be copied over when the connect provider confirm comes in.
|
||
*/
|
||
if (NULL != domain_parameters)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pDomainParameters = new DomainParameters;
|
||
if (NULL == m_pDomainParameters)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: can't create DomainParameters"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
|
||
// structure-wide shallow copy
|
||
*m_pDomainParameters = *domain_parameters;
|
||
}
|
||
|
||
/*
|
||
** If the called address equals NULL this node will be both the Top
|
||
** Provider and the Convener. In this case there is no need to send out the
|
||
** ConfCreateRq PDU. Instead we go ahead and create the User Object. If the
|
||
** conference is created with someone else, wait until the response is
|
||
** returned before creating the User Object.
|
||
*/
|
||
if (NULL != called_address)
|
||
{
|
||
// Set up the node type
|
||
m_eNodeType = CONVENER_NODE;
|
||
|
||
/*
|
||
** Create the ConferenceCreateRequest PDU here.
|
||
*/
|
||
connect_pdu.choice = CONFERENCE_CREATE_REQUEST_CHOSEN;
|
||
connect_pdu.u.conference_create_request.bit_mask = 0;
|
||
|
||
// Encode the conference name
|
||
connect_pdu.u.conference_create_request.conference_name.bit_mask = 0;
|
||
|
||
// Encode the numeric portion of the name
|
||
::lstrcpyA(connect_pdu.u.conference_create_request.conference_name.numeric,
|
||
m_pszConfNumericName);
|
||
|
||
// Encode the text portion of the conference name if it exists
|
||
if (NULL != m_pwszConfTextName)
|
||
{
|
||
connect_pdu.u.conference_create_request.conference_name.bit_mask |=
|
||
CONFERENCE_NAME_TEXT_PRESENT;
|
||
connect_pdu.u.conference_create_request.conference_name.conference_name_text.value =
|
||
m_pwszConfTextName;
|
||
connect_pdu.u.conference_create_request.conference_name.conference_name_text.length =
|
||
::lstrlenW(m_pwszConfTextName);
|
||
}
|
||
|
||
// Encode the convener password if one exists.
|
||
if (NULL != convener_password)
|
||
{
|
||
rc = convener_password->GetPasswordPDU(
|
||
&connect_pdu.u.conference_create_request.ccrq_convener_password);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: can't get convenor password, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_create_request.bit_mask |= CCRQ_CONVENER_PASSWORD_PRESENT;
|
||
}
|
||
|
||
// Encode the convener password if one exists.
|
||
if (NULL != password)
|
||
{
|
||
rc = password->GetPasswordPDU(
|
||
&connect_pdu.u.conference_create_request.ccrq_password);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: can't get password, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_create_request.bit_mask |= CCRQ_PASSWORD_PRESENT;
|
||
}
|
||
|
||
// Encode the privilege list
|
||
if (NULL != m_pConductorPrivilegeList)
|
||
{
|
||
rc = m_pConductorPrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.conference_create_request.ccrq_conductor_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: can't get conductor's privileges, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_create_request.bit_mask |= CCRQ_CONDUCTOR_PRIVS_PRESENT;
|
||
}
|
||
|
||
if (NULL != m_pConductModePrivilegeList)
|
||
{
|
||
rc = m_pConductModePrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.conference_create_request.ccrq_conducted_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: can't get conduct mode privileges, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_create_request.bit_mask |= CCRQ_CONDUCTED_PRIVS_PRESENT;
|
||
}
|
||
|
||
if (NULL != m_pNonConductModePrivilegeList)
|
||
{
|
||
rc = m_pNonConductModePrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.conference_create_request.ccrq_non_conducted_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: can't get non-conduct mode privileges, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_create_request.bit_mask |=
|
||
CCRQ_NON_CONDUCTED_PRIVS_PRESENT;
|
||
}
|
||
|
||
// Encode the conference descriptor
|
||
if (NULL != m_pwszConfDescription)
|
||
{
|
||
connect_pdu.u.conference_create_request.bit_mask |= CCRQ_DESCRIPTION_PRESENT;
|
||
|
||
connect_pdu.u.conference_create_request.ccrq_description.length =
|
||
::lstrlenW(m_pwszConfDescription);
|
||
|
||
connect_pdu.u.conference_create_request.ccrq_description.value =
|
||
m_pwszConfDescription;
|
||
}
|
||
|
||
// Encode the caller identifier if on exists.
|
||
if (NULL != pwszCallerID)
|
||
{
|
||
connect_pdu.u.conference_create_request.bit_mask |= CCRQ_CALLER_ID_PRESENT;
|
||
connect_pdu.u.conference_create_request.ccrq_caller_id.length = ::lstrlenW(pwszCallerID);
|
||
connect_pdu.u.conference_create_request.ccrq_caller_id.value = pwszCallerID;
|
||
}
|
||
|
||
// Encode the user data if any exists
|
||
if (NULL != user_data_list)
|
||
{
|
||
rc = user_data_list->GetUserDataPDU(
|
||
&connect_pdu.u.conference_create_request.ccrq_user_data);
|
||
if (GCC_NO_ERROR != NULL)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: can't get user data, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_create_request.bit_mask |= CCRQ_USER_DATA_PRESENT;
|
||
}
|
||
|
||
connect_pdu.u.conference_create_request.conference_is_locked = (ASN1bool_t)m_fConfLocked;
|
||
connect_pdu.u.conference_create_request.conference_is_listed = (ASN1bool_t)m_fConfListed;
|
||
connect_pdu.u.conference_create_request.conference_is_conductible = (ASN1bool_t)m_fConfConductible;
|
||
connect_pdu.u.conference_create_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::ConfCreateRequest: 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,
|
||
TRUE, // Upward connection
|
||
encoded_pdu,
|
||
encoded_pdu_length,
|
||
&m_hParentConnection,
|
||
m_pDomainParameters,
|
||
this);
|
||
|
||
g_GCCCoder->FreeEncoded(encoded_pdu);
|
||
*connection_handle = m_hParentConnection;
|
||
|
||
if (MCS_NO_ERROR != mcs_error)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateRequest: ConnectProviderRequest call 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;
|
||
}
|
||
|
||
// Free the privilege list packed into structures for encoding
|
||
if (connect_pdu.u.conference_create_request.bit_mask & CCRQ_CONDUCTOR_PRIVS_PRESENT)
|
||
{
|
||
m_pConductorPrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.conference_create_request.ccrq_conductor_privs);
|
||
}
|
||
|
||
if (connect_pdu.u.conference_create_request.bit_mask & CCRQ_CONDUCTED_PRIVS_PRESENT)
|
||
{
|
||
m_pConductModePrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.conference_create_request.ccrq_conducted_privs);
|
||
}
|
||
|
||
if (connect_pdu.u.conference_create_request.bit_mask & CCRQ_NON_CONDUCTED_PRIVS_PRESENT)
|
||
{
|
||
m_pNonConductModePrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.conference_create_request.ccrq_non_conducted_privs);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
*connection_handle = NULL;
|
||
m_eNodeType = TOP_PROVIDER_AND_CONVENER_NODE;
|
||
DBG_SAVE_FILE_LINE
|
||
m_pMcsUserObject = new MCSUser(this, 0, 0, &rc);
|
||
if (NULL == m_pMcsUserObject || GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf: ConfCreateRequest: can't create mcs user object, rc=%d", rc));
|
||
if (NULL != m_pMcsUserObject)
|
||
{
|
||
m_pMcsUserObject->Release();
|
||
m_pMcsUserObject = NULL;
|
||
}
|
||
else
|
||
{
|
||
rc = GCC_ALLOCATION_FAILURE; // rc may be a different value
|
||
}
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
m_fSecure = fSecure;
|
||
|
||
rc = GCC_NO_ERROR;
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
if (NULL != domain_parameters)
|
||
{
|
||
delete m_pDomainParameters;
|
||
m_pDomainParameters = NULL;
|
||
}
|
||
}
|
||
|
||
DebugExitINT(CConf::ConferenceCreateRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ConfCreateResponse ()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a
|
||
* ConferenceCreateResponse primitive needs to be processed.
|
||
* Note that this should only be called when the result of
|
||
* the response is success. Only the top provider receives the
|
||
* conference create response.
|
||
*
|
||
* Caveats
|
||
* All errors should be handled directly by the calling application.
|
||
* This includes deletion of the conference object and notification
|
||
* to the node controller that the conference was abnormally
|
||
* terminated.
|
||
*/
|
||
GCCError CConf::
|
||
ConfCreateResponse
|
||
(
|
||
ConnectionHandle connection_handle,
|
||
PDomainParameters domain_parameters,
|
||
CUserDataListContainer *user_data_list
|
||
)
|
||
{
|
||
GCCError rc = GCC_ALLOCATION_FAILURE;
|
||
|
||
DebugEntry(CConf::ConfCreateResponse);
|
||
|
||
// Conference Create Responses can only be received at the top provider
|
||
m_eNodeType = TOP_PROVIDER_NODE;
|
||
|
||
/*
|
||
** First make a copy of the new domain parameters if they exists. We do
|
||
** this here so that they can be passed in when we perform the Connect
|
||
** Provider Response.
|
||
*/
|
||
if (domain_parameters != NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pDomainParameters = new DomainParameters;
|
||
if (NULL == m_pDomainParameters)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateResponse: can't create domain parameters"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
|
||
// structure-wide shallow copy
|
||
*m_pDomainParameters = *domain_parameters;
|
||
}
|
||
|
||
// Store the child connection in the list of connection handles
|
||
ASSERT(0 != connection_handle);
|
||
m_ConnHandleList.Append(connection_handle);
|
||
|
||
/*
|
||
** The convener connection handle is stored seperately so that
|
||
** the Connect Provider response can be sent on the right
|
||
** connection. This may be overkill but I was a little concerned
|
||
** about pulling this out of the list even though this should be
|
||
** the only entry in the list when it's time to send the response.
|
||
*/
|
||
m_hConvenerConnection = connection_handle;
|
||
|
||
if (user_data_list != NULL)
|
||
{
|
||
/*
|
||
** Since we must wait until the user attachment is fully
|
||
** established before we send the response we must save the user
|
||
** data list in a temporary container.
|
||
*/
|
||
m_pUserDataList = user_data_list;
|
||
|
||
// Lock the user data in memory
|
||
m_pUserDataList->LockUserDataList();
|
||
}
|
||
|
||
/*
|
||
** Now create the user attachment object and wait for the confirm
|
||
** which occurs after all the proper channels are joined. The
|
||
** user object will determine the top provider ID. When the user
|
||
** create confirm is received the response PDU will be sent out
|
||
** in the Connect Provider Response.
|
||
*/
|
||
DBG_SAVE_FILE_LINE
|
||
m_pMcsUserObject = new MCSUser(this, 0, 0, &rc);
|
||
if (NULL == m_pMcsUserObject || GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfCreateResponse: can't create mcs user object, rc=%d", rc));
|
||
if (NULL != m_pMcsUserObject)
|
||
{
|
||
m_pMcsUserObject->Release();
|
||
m_pMcsUserObject = NULL;
|
||
}
|
||
else
|
||
{
|
||
rc = GCC_ALLOCATION_FAILURE; // rc may be a different value
|
||
}
|
||
goto MyExit;
|
||
}
|
||
|
||
rc = GCC_NO_ERROR;
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
if (NULL != domain_parameters)
|
||
{
|
||
delete m_pDomainParameters;
|
||
m_pDomainParameters = NULL;
|
||
}
|
||
}
|
||
|
||
DebugExitINT(CConf::ConferenceCreateResponse, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::ConfJoinRequest()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a
|
||
* ConferenceJoinRequest primitive received from the node controller needs
|
||
* to be processed. This routine sends a JoinRequest PDU to its parent
|
||
* node through an MCS Connect Provider Request.
|
||
*
|
||
* Caveats
|
||
* All errors should be handled directly by the calling application.
|
||
* This includes deletion of the conference object.
|
||
*/
|
||
GCCError CConf::
|
||
ConfJoinRequest
|
||
(
|
||
GCCNumericString called_node_modifier,
|
||
CPassword *convener_password,
|
||
CPassword *password_challenge,
|
||
LPWSTR pwszCallerID,
|
||
TransportAddress calling_address,
|
||
TransportAddress called_address,
|
||
BOOL fSecure,
|
||
PDomainParameters domain_parameters,
|
||
CUserDataListContainer *user_data_list,
|
||
PConnectionHandle connection_handle
|
||
)
|
||
{
|
||
GCCError rc = GCC_ALLOCATION_FAILURE;
|
||
LPBYTE encoded_pdu;
|
||
UINT encoded_pdu_length;
|
||
MCSError mcs_error;
|
||
ConnectGCCPDU connect_pdu;
|
||
|
||
DebugEntry(CConf::ConfJoinRequest);
|
||
|
||
ASSERT(FALSE == m_fSecure);
|
||
m_fSecure = fSecure;
|
||
|
||
/*
|
||
** First make a copy of the new domain parameters if they exists. These
|
||
** will be copied over when the connect provider confirm comes in.
|
||
*/
|
||
if (domain_parameters != NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pDomainParameters = new DomainParameters;
|
||
if (NULL == m_pDomainParameters)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinRequest: can't create domain parameters"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
|
||
*m_pDomainParameters = *domain_parameters;
|
||
}
|
||
|
||
m_eNodeType = (NULL == convener_password) ?
|
||
// Node type must be joined when receiving this request
|
||
JOINED_NODE :
|
||
// Node type must be joined convener when receiving this request
|
||
JOINED_CONVENER_NODE;
|
||
|
||
// Create the ConferenceJoinRequest PDU here.
|
||
connect_pdu.choice = CONNECT_JOIN_REQUEST_CHOSEN;
|
||
|
||
connect_pdu.u.connect_join_request.bit_mask = CONFERENCE_NAME_PRESENT;
|
||
|
||
if (NULL != m_pszConfNumericName && '\0' != *m_pszConfNumericName)
|
||
{
|
||
// Send the numeric portion of the conference name
|
||
connect_pdu.u.connect_join_request.conference_name.choice = NAME_SELECTOR_NUMERIC_CHOSEN;
|
||
|
||
::lstrcpyA(connect_pdu.u.connect_join_request.conference_name.u.name_selector_numeric,
|
||
m_pszConfNumericName);
|
||
}
|
||
else
|
||
{
|
||
// Send the text portion of the conference name
|
||
connect_pdu.u.connect_join_request.conference_name.choice = NAME_SELECTOR_TEXT_CHOSEN;
|
||
|
||
connect_pdu.u.connect_join_request.conference_name.u.name_selector_text.length =
|
||
::lstrlenW(m_pwszConfTextName);
|
||
connect_pdu.u.connect_join_request.conference_name.u.name_selector_text.value =
|
||
m_pwszConfTextName;
|
||
}
|
||
|
||
// Fill in the remote node modifier if one exists
|
||
if (NULL != called_node_modifier)
|
||
{
|
||
// Save the remote modifier so that it can be returned in the confirm
|
||
if (NULL == (m_pszRemoteModifier = ::My_strdupA(called_node_modifier)))
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinRequest: can't create remote modifier"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_request.bit_mask |= CJRQ_CONFERENCE_MODIFIER_PRESENT;
|
||
::lstrcpyA(connect_pdu.u.connect_join_request.cjrq_conference_modifier,
|
||
(LPCSTR) called_node_modifier);
|
||
}
|
||
|
||
// Fill in the convener password selector.
|
||
if (NULL != convener_password)
|
||
{
|
||
rc = convener_password->GetPasswordSelectorPDU(
|
||
&connect_pdu.u.connect_join_request.cjrq_convener_password);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinRequest: can't get password selector, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_request.bit_mask |= CJRQ_CONVENER_PASSWORD_PRESENT;
|
||
}
|
||
|
||
// Fill in the password challenge
|
||
if (NULL != password_challenge)
|
||
{
|
||
rc = password_challenge->GetPasswordChallengeResponsePDU(
|
||
&connect_pdu.u.connect_join_request.cjrq_password);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinRequest: can't get password challenge response, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_request.bit_mask |=CJRQ_PASSWORD_PRESENT;
|
||
}
|
||
|
||
|
||
// Fill in the caller identifier if one exists
|
||
if (NULL != pwszCallerID)
|
||
{
|
||
connect_pdu.u.connect_join_request.bit_mask |= CJRQ_CALLER_ID_PRESENT;
|
||
connect_pdu.u.connect_join_request.cjrq_caller_id.value = pwszCallerID;
|
||
connect_pdu.u.connect_join_request.cjrq_caller_id.length = ::lstrlenW(pwszCallerID);
|
||
}
|
||
|
||
// Fill in the user data if it exists
|
||
if (NULL != user_data_list)
|
||
{
|
||
rc = user_data_list->GetUserDataPDU(
|
||
&connect_pdu.u.connect_join_request.cjrq_user_data);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinRequest: can't get user data, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_request.bit_mask |= CJRQ_USER_DATA_PRESENT;
|
||
}
|
||
|
||
if (! g_GCCCoder->Encode((LPVOID) &connect_pdu,
|
||
CONNECT_GCC_PDU,
|
||
PACKED_ENCODING_RULES,
|
||
&encoded_pdu,
|
||
&encoded_pdu_length))
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinRequest: can't encode"));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** Note that the TransportStrings are casted twice here. It
|
||
** must be done this way to satisfy the compiler. Sorry about
|
||
** not adhearing to coding standards.
|
||
*/
|
||
mcs_error = g_pMCSIntf->ConnectProviderRequest(
|
||
&m_nConfID, // calling domain selector
|
||
&m_nConfID, // called domain selector
|
||
calling_address,
|
||
called_address,
|
||
m_fSecure,
|
||
TRUE, // Upward connection
|
||
encoded_pdu,
|
||
encoded_pdu_length,
|
||
&m_hParentConnection,
|
||
m_pDomainParameters,
|
||
this);
|
||
|
||
g_GCCCoder->FreeEncoded(encoded_pdu);
|
||
|
||
*connection_handle = m_hParentConnection;
|
||
|
||
if (MCS_NO_ERROR != mcs_error)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinRequest: can't connect provider request, 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;
|
||
}
|
||
|
||
rc = GCC_NO_ERROR;
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
if (NULL != domain_parameters)
|
||
{
|
||
delete m_pDomainParameters;
|
||
m_pDomainParameters = NULL;
|
||
}
|
||
|
||
if (NULL != called_node_modifier)
|
||
{
|
||
delete m_pszRemoteModifier;
|
||
m_pszRemoteModifier = NULL;
|
||
}
|
||
}
|
||
|
||
DebugExitINT(CConf:ConferenceJoinRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
/*
|
||
* CConf::ForwardConfJoinRequest ()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a conference join
|
||
* request is received for a conference that is at a node that is not the
|
||
* Top Provider. This routine forwards the request on up to the Top
|
||
* Provider.
|
||
*
|
||
* Caveats
|
||
* This routine should never be called if this node is the Top Provider.
|
||
*/
|
||
GCCError CConf::
|
||
ForwardConfJoinRequest
|
||
(
|
||
CPassword *convener_password,
|
||
CPassword *password_challange,
|
||
LPWSTR pwszCallerID,
|
||
CUserDataListContainer *user_data_list,
|
||
BOOL numeric_name_present,
|
||
ConnectionHandle connection_handle
|
||
)
|
||
{
|
||
GCCError rc;
|
||
|
||
DebugEntry(CConf::ForwardConfJoinRequest);
|
||
|
||
/*
|
||
** If the node is the top provider we will go ahead and send the
|
||
** join indication to the node controller, otherwise we will pass
|
||
** the request on up to the top provider.
|
||
*/
|
||
if (IsConfTopProvider())
|
||
{
|
||
WARNING_OUT(("CConf::GCCConferenceJoinIndication: not top provider"));
|
||
rc = GCC_INVALID_CONFERENCE;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** The connection handle is used as the tag which is sent in the request
|
||
** and returned in the response. Note that it is the user objects
|
||
** responsiblity to resolve any type conflicts with the tag.
|
||
*/
|
||
if (NULL == m_pMcsUserObject)
|
||
{
|
||
ERROR_OUT(("CConf::GCCConferenceJoinIndication: invalid mcs user object"));
|
||
rc = GCC_INVALID_CONFERENCE;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** This list holds information about the conference name alias that
|
||
** must be returned in the join response. When the reponse comes
|
||
** back from the top provider, the information can be obtained from
|
||
** this list.
|
||
*/
|
||
m_JoinRespNamePresentConnHdlList2.Append(connection_handle, numeric_name_present ? TRUE_PTR : FALSE_PTR);
|
||
|
||
// The user object is responsible for encoding this PDU
|
||
rc = m_pMcsUserObject->ConferenceJoinRequest(convener_password,
|
||
password_challange,
|
||
pwszCallerID,
|
||
user_data_list,
|
||
connection_handle);
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::ForwardConfJoinRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
/*
|
||
* CConf::ConfJoinIndResponse()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a
|
||
* ConferenceJoinResponse primitive is received from the node controller.
|
||
* It is also called when a ConferenceJoinResponse is received from the
|
||
* Top Provider.
|
||
*
|
||
* Caveats
|
||
* If the GCC_DOMAIN_PARAMETERS_UNACCEPTABLE error is returned from this
|
||
* routine, MCS will automatically reject the connection sending a
|
||
* result to the other side stating the the Domain Parameters were
|
||
* unacceptable.
|
||
*/
|
||
GCCError CConf::
|
||
ConfJoinIndResponse
|
||
(
|
||
ConnectionHandle connection_handle,
|
||
CPassword *password_challenge,
|
||
CUserDataListContainer *user_data_list,
|
||
BOOL numeric_name_present,
|
||
BOOL convener_is_joining,
|
||
GCCResult result
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
MCSError mcs_error;
|
||
LPBYTE encoded_pdu;
|
||
UINT encoded_pdu_length;
|
||
ConnectGCCPDU connect_pdu;
|
||
Result mcs_result;
|
||
|
||
DebugEntry(CConf::ConfJoinIndResponse);
|
||
|
||
// Set up the MCS result for the connect provider response.
|
||
mcs_result = (result == GCC_RESULT_SUCCESSFUL) ?
|
||
RESULT_SUCCESSFUL :
|
||
RESULT_USER_REJECTED;
|
||
|
||
// Encode the PDU
|
||
connect_pdu.choice = CONNECT_JOIN_RESPONSE_CHOSEN;
|
||
connect_pdu.u.connect_join_response.bit_mask = CJRS_NODE_ID_PRESENT;
|
||
|
||
if (result == GCC_RESULT_SUCCESSFUL)
|
||
{
|
||
// Check to see if it is necessary to send the conference name alias
|
||
if (numeric_name_present && (m_pwszConfTextName != NULL))
|
||
{
|
||
connect_pdu.u.connect_join_response.bit_mask |= CONFERENCE_NAME_ALIAS_PRESENT;
|
||
|
||
connect_pdu.u.connect_join_response.conference_name_alias.choice =
|
||
NAME_SELECTOR_TEXT_CHOSEN;
|
||
|
||
connect_pdu.u.connect_join_response.conference_name_alias.u.name_selector_text.value =
|
||
m_pwszConfTextName;
|
||
|
||
connect_pdu.u.connect_join_response.conference_name_alias.u.name_selector_text.length =
|
||
::lstrlenW(m_pwszConfTextName);
|
||
}
|
||
else
|
||
if (! numeric_name_present)
|
||
{
|
||
connect_pdu.u.connect_join_response.bit_mask |=
|
||
CONFERENCE_NAME_ALIAS_PRESENT;
|
||
|
||
connect_pdu.u.connect_join_response.conference_name_alias.choice =
|
||
NAME_SELECTOR_NUMERIC_CHOSEN;
|
||
|
||
lstrcpy (connect_pdu.u.connect_join_response.conference_name_alias.u.name_selector_numeric,
|
||
m_pszConfNumericName);
|
||
}
|
||
|
||
// Get the conductor privilege list
|
||
if (NULL != m_pConductorPrivilegeList)
|
||
{
|
||
rc = m_pConductorPrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.connect_join_response.cjrs_conductor_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinIndResponse: can't get privilege, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_response.bit_mask |= CJRS_CONDUCTOR_PRIVS_PRESENT;
|
||
}
|
||
|
||
// Get the conducted mode privilege list
|
||
if (NULL != m_pConductModePrivilegeList)
|
||
{
|
||
rc = m_pConductModePrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.connect_join_response.cjrs_conducted_privs);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinIndResponse: can't get conduct mode privilege, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_response.bit_mask |= CJRS_CONDUCTED_PRIVS_PRESENT;
|
||
}
|
||
|
||
// Get the non conducted mode privilege list
|
||
if (NULL != m_pNonConductModePrivilegeList)
|
||
{
|
||
rc = m_pNonConductModePrivilegeList->GetPrivilegeListPDU(
|
||
&connect_pdu.u.connect_join_response.cjrs_non_conducted_privs);
|
||
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinIndResponse: can't get non-conduct mode privilege, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_response.bit_mask |= CJRS_NON_CONDUCTED_PRIVS_PRESENT;
|
||
}
|
||
|
||
// Get the conference description
|
||
if (NULL != m_pwszConfDescription)
|
||
{
|
||
connect_pdu.u.connect_join_response.cjrs_description.length =
|
||
::lstrlenW(m_pwszConfDescription);
|
||
connect_pdu.u.connect_join_response.cjrs_description.value =
|
||
m_pwszConfDescription;
|
||
connect_pdu.u.connect_join_response.bit_mask |= CJRS_DESCRIPTION_PRESENT;
|
||
}
|
||
}
|
||
|
||
// Get the password challenge
|
||
if (NULL != password_challenge)
|
||
{
|
||
rc = password_challenge->GetPasswordChallengeResponsePDU (
|
||
&connect_pdu.u.connect_join_response.cjrs_password);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinIndResponse: can't get password challenge response, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_response.bit_mask |= CJRS_PASSWORD_PRESENT;
|
||
}
|
||
|
||
// Get the user data list
|
||
if (NULL != user_data_list)
|
||
{
|
||
rc = user_data_list->GetUserDataPDU(&connect_pdu.u.connect_join_response.cjrs_user_data);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinIndResponse: can't get user data, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_response.bit_mask |= CJRS_USER_DATA_PRESENT;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_response.tag = GetNewUserIDTag ();
|
||
|
||
/*
|
||
** if this is the convener rejoining the conference, we save
|
||
** the user id tag so that we can record the convener id when it
|
||
** is returned in the user id indication.
|
||
*/
|
||
if (convener_is_joining &&
|
||
((m_eNodeType == TOP_PROVIDER_NODE) ||
|
||
(m_eNodeType == TOP_PROVIDER_AND_CONVENER_NODE)))
|
||
{
|
||
m_nConvenerUserIDTagNumber = connect_pdu.u.connect_join_response.tag;
|
||
}
|
||
|
||
connect_pdu.u.connect_join_response.cjrs_node_id = m_pMcsUserObject->GetMyNodeID();
|
||
connect_pdu.u.connect_join_response.top_node_id = m_pMcsUserObject->GetTopNodeID();
|
||
connect_pdu.u.connect_join_response.clear_password_required = (ASN1bool_t)m_fClearPassword;
|
||
connect_pdu.u.connect_join_response.conference_is_locked = (ASN1bool_t)m_fConfLocked;
|
||
connect_pdu.u.connect_join_response.conference_is_listed = (ASN1bool_t)m_fConfListed;
|
||
connect_pdu.u.connect_join_response.conference_is_conductible = (ASN1bool_t)m_fConfConductible;
|
||
connect_pdu.u.connect_join_response.termination_method = (TerminationMethod)m_eTerminationMethod;
|
||
connect_pdu.u.connect_join_response.result = ::TranslateGCCResultToJoinResult(result);
|
||
|
||
if (! g_GCCCoder->Encode((LPVOID) &connect_pdu,
|
||
CONNECT_GCC_PDU,
|
||
PACKED_ENCODING_RULES,
|
||
&encoded_pdu,
|
||
&encoded_pdu_length))
|
||
{
|
||
ERROR_OUT(("CConf::ConfJoinIndResponse: can't encode"));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
goto MyExit;
|
||
}
|
||
|
||
mcs_error = g_pMCSIntf->ConnectProviderResponse(
|
||
connection_handle,
|
||
&m_nConfID,
|
||
m_pDomainParameters,
|
||
mcs_result,
|
||
encoded_pdu,
|
||
encoded_pdu_length);
|
||
|
||
g_GCCCoder->FreeEncoded(encoded_pdu);
|
||
|
||
if ((mcs_error == MCS_NO_ERROR) &&
|
||
(result == GCC_RESULT_SUCCESSFUL))
|
||
{
|
||
/*
|
||
** Add the connection handle to our list of
|
||
** connection handles.
|
||
*/
|
||
ASSERT(0 != connection_handle);
|
||
m_ConnHandleList.Append(connection_handle);
|
||
|
||
/*
|
||
** Add the user's tag number to the list of outstanding
|
||
** user ids along with its associated connection.
|
||
*/
|
||
m_ConnHdlTagNumberList2.Append(connect_pdu.u.connect_join_response.tag, connection_handle);
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT(("CConf::ConfJoinIndResponse: ConnectProviderResponse failed, mcs_error=%d, result=%d", mcs_error, result));
|
||
rc = g_pMCSIntf->TranslateMCSIFErrorToGCCError(mcs_error);
|
||
goto MyExit;
|
||
}
|
||
|
||
// Free up any memory allocated by the conatiners to build the PDU structs
|
||
if (connect_pdu.u.connect_join_response.bit_mask & CJRS_CONDUCTOR_PRIVS_PRESENT)
|
||
{
|
||
m_pConductorPrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.connect_join_response.cjrs_conductor_privs);
|
||
}
|
||
|
||
if (connect_pdu.u.connect_join_response.bit_mask & CJRS_CONDUCTED_PRIVS_PRESENT)
|
||
{
|
||
m_pConductModePrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.connect_join_response.cjrs_conducted_privs);
|
||
}
|
||
|
||
if (connect_pdu.u.connect_join_response.bit_mask & CJRS_NON_CONDUCTED_PRIVS_PRESENT)
|
||
{
|
||
m_pNonConductModePrivilegeList->FreePrivilegeListPDU(
|
||
connect_pdu.u.connect_join_response.cjrs_non_conducted_privs);
|
||
}
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
g_pGCCController->FailConfJoinIndResponse(m_nConfID, connection_handle);
|
||
}
|
||
|
||
g_pGCCController->RemoveConfJoinInfo(connection_handle);
|
||
|
||
DebugExitINT(CConf::ConfJoinIndResponse, rc);
|
||
return rc;
|
||
}
|
||
|
||
/*
|
||
* CConf::ConfInviteResponse()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a
|
||
* ConferenceInviteResponse primitive needs to be processed.
|
||
*/
|
||
GCCError CConf::
|
||
ConfInviteResponse
|
||
(
|
||
UserID parent_user_id,
|
||
UserID top_user_id,
|
||
TagNumber tag_number,
|
||
ConnectionHandle connection_handle,
|
||
BOOL fSecure,
|
||
PDomainParameters domain_parameters,
|
||
CUserDataListContainer *user_data_list
|
||
)
|
||
{
|
||
GCCError rc = GCC_ALLOCATION_FAILURE;
|
||
LPBYTE encoded_pdu;
|
||
UINT encoded_pdu_length;
|
||
MCSError mcs_error;
|
||
ConnectGCCPDU connect_pdu;
|
||
|
||
DebugEntry(CConf::ConfInviteResponse);
|
||
|
||
ASSERT(FALSE == m_fSecure);
|
||
m_fSecure = fSecure;
|
||
|
||
// First make a copy of the new domain parameters if they exists
|
||
if (domain_parameters != NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pDomainParameters = new DomainParameters;
|
||
if (NULL == m_pDomainParameters)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteResponse: can't create domain parameters"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
|
||
// structure-wide shallow copy
|
||
*m_pDomainParameters = *domain_parameters;
|
||
}
|
||
|
||
m_eNodeType = INVITED_NODE;
|
||
|
||
m_nParentIDTagNumber = tag_number;
|
||
m_hParentConnection = connection_handle;
|
||
|
||
/*
|
||
** First we must send the invite response back to the requester.
|
||
** If we've gotten this far it will always be a positive response.
|
||
*/
|
||
|
||
// Create the ConferenceInviteRequest PDU here.
|
||
connect_pdu.choice = CONFERENCE_INVITE_RESPONSE_CHOSEN;
|
||
connect_pdu.u.conference_invite_response.bit_mask = 0;
|
||
|
||
if (user_data_list != NULL)
|
||
{
|
||
rc = user_data_list->GetUserDataPDU(
|
||
&connect_pdu.u.conference_invite_response.cirs_user_data);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteResponse: can't get user data, rc=%d", rc));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
|
||
connect_pdu.u.conference_invite_response.bit_mask |= CIRS_USER_DATA_PRESENT;
|
||
}
|
||
|
||
connect_pdu.u.conference_invite_response.result =
|
||
::TranslateGCCResultToInviteResult(GCC_RESULT_SUCCESSFUL);
|
||
if (! g_GCCCoder->Encode((LPVOID) &connect_pdu,
|
||
CONNECT_GCC_PDU,
|
||
PACKED_ENCODING_RULES,
|
||
&encoded_pdu,
|
||
&encoded_pdu_length))
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteResponse: can't encode"));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** Note that the TransportStrings are casted twice here. It
|
||
** must be done this way to satisfy the compiler. Sorry about
|
||
** not adhearing to coding standards.
|
||
*/
|
||
mcs_error = g_pMCSIntf->ConnectProviderResponse (
|
||
connection_handle,
|
||
&m_nConfID,
|
||
m_pDomainParameters,
|
||
RESULT_SUCCESSFUL,
|
||
encoded_pdu,
|
||
encoded_pdu_length);
|
||
|
||
g_GCCCoder->FreeEncoded(encoded_pdu);
|
||
|
||
if (MCS_NO_ERROR != mcs_error)
|
||
{
|
||
WARNING_OUT(("CConf::ConfInviteResponse: ConnectProviderRequest failed: rc=%d", mcs_error));
|
||
rc = g_pMCSIntf->TranslateMCSIFErrorToGCCError(mcs_error);
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** Now create the user attachment object and wait for the
|
||
** confirm which occurs after all the proper channels are
|
||
** joined. The user object will determine the top provider ID.
|
||
** When the user create confirm is received the response PDU
|
||
** will be sent out in the Connect Provider Response.
|
||
*/
|
||
DBG_SAVE_FILE_LINE
|
||
m_pMcsUserObject = new MCSUser(this, top_user_id, parent_user_id, &rc);
|
||
if (NULL == m_pMcsUserObject || GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::ConfInviteResponse: Creation of User Attachment failed, rc=%d", rc));
|
||
if (NULL != m_pMcsUserObject)
|
||
{
|
||
m_pMcsUserObject->Release();
|
||
m_pMcsUserObject = NULL;
|
||
}
|
||
else
|
||
{
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
goto MyExit;
|
||
}
|
||
|
||
rc = GCC_NO_ERROR;
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
if (NULL != domain_parameters)
|
||
{
|
||
delete m_pDomainParameters;
|
||
m_pDomainParameters = NULL;
|
||
}
|
||
}
|
||
|
||
DebugExitINT(CConf::ConfInviteResponse, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::RegisterAppSap()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object whenever an application
|
||
* SAP becomes a candidate for Enrollment. This will happen whenever
|
||
* Applications SAPs exists at the same time a conference becomes
|
||
* established. It will also be called whenever a conference exists
|
||
* and a new application SAP is created.
|
||
*/
|
||
GCCError CConf::
|
||
RegisterAppSap ( CAppSap *pAppSap )
|
||
{
|
||
GCCError rc;
|
||
GCCConferenceName conference_name;
|
||
GCCNumericString conference_modifier;
|
||
|
||
DebugEntry(CConf::RegisterAppSap);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
/*
|
||
** We first check to see if the application is already registered.
|
||
** If so, we do not add it to the list of registered applications
|
||
** again.
|
||
*/
|
||
if (NULL == m_RegisteredAppSapList.Find(pAppSap))
|
||
{
|
||
// Add the application sap pointer to the registered sap list.
|
||
pAppSap->AddRef();
|
||
m_RegisteredAppSapList.Append(pAppSap);
|
||
|
||
/*
|
||
** Get the conference name and modifier to send back in the
|
||
** permission to enroll indication.
|
||
*/
|
||
GetConferenceNameAndModifier(&conference_name, &conference_modifier);
|
||
|
||
// Inform the application that it can now enroll.
|
||
pAppSap->PermissionToEnrollIndication(m_nConfID, TRUE);
|
||
}
|
||
|
||
rc = GCC_NO_ERROR;
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::RegisterAppSap: CConf not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf::RegisterAppSap, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::UnRegisterAppSap ()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object whenever an application
|
||
* SAP becomes unavailable due to whatever reason. This routine is
|
||
* responsible for unenrolling any APEs from any rosters that it might have
|
||
* used this SAP to enroll with.
|
||
*/
|
||
GCCError CConf::
|
||
UnRegisterAppSap ( CAppSap *pAppSap )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCConferenceName conference_name;
|
||
GCCNumericString conference_modifier;
|
||
|
||
DebugEntry(CConf::UnRegisterAppSap);
|
||
|
||
/*
|
||
** We first check to see if the application is already registered.
|
||
** If so, we do not add it to the list of registered applications
|
||
** again.
|
||
*/
|
||
if (! m_RegisteredAppSapList.Find(pAppSap))
|
||
{
|
||
TRACE_OUT(("CConf::UnRegisterAppSap: app not registered"));
|
||
rc = GCC_APPLICATION_NOT_REGISTERED;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** Get the conference name and modifier to send back in the
|
||
** permission to enroll indication.
|
||
*/
|
||
GetConferenceNameAndModifier(&conference_name, &conference_modifier);
|
||
|
||
// Inform the application that it can no longer enroll.
|
||
pAppSap->PermissionToEnrollIndication(m_nConfID, FALSE);
|
||
|
||
/*
|
||
** We unenroll the appropriate APE. Note that we will only send roster updates
|
||
** if the conference is established.
|
||
*/
|
||
RemoveSAPFromAPEList(pAppSap);
|
||
|
||
#if 0 // LONCHANC: UnRegisterAppSap should not affect the roster.
|
||
// Only UnenrollApp will affect the app roster.
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
/*
|
||
** Here we flush any PDU data or messages that might have gotten
|
||
** queued up when this SAP we was being unenrolled.
|
||
** An error here is considered FATAL in that the conference
|
||
** information base at this node is now corrupted therefore we
|
||
** terminate the conference.
|
||
*/
|
||
rc = AsynchFlushRosterData();
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::UnRegisterAppSap: can't flush roster data, rc=%d", rc));
|
||
//
|
||
// Do not need to initiate termination because we are
|
||
// either already in termination procedure or
|
||
// the application is going away.
|
||
//
|
||
#if 0
|
||
InitiateTermination((rc == GCC_ALLOCATION_FAILURE) ?
|
||
GCC_REASON_ERROR_LOW_RESOURCES :
|
||
GCC_REASON_ERROR_TERMINATION,
|
||
0);
|
||
#endif // 0
|
||
goto MyExit;
|
||
}
|
||
}
|
||
#endif // 0
|
||
|
||
// Remove the application sap from list of registered SAPs
|
||
if (m_RegisteredAppSapList.Remove(pAppSap))
|
||
{
|
||
//
|
||
// Only when this app sap is still in the list, we then can
|
||
// release it. It is possible that this app sap has been
|
||
// unregistered by the app due to permission-to-enroll-ind
|
||
// we just sent earlier.
|
||
//
|
||
pAppSap->Release();
|
||
}
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::UnRegisterAppSap, rc);
|
||
return rc;
|
||
}
|
||
|
||
/*
|
||
* CConf::AppEnrollRequest()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when an
|
||
* Application is requesting to enroll with this conference.
|
||
*
|
||
* Caveats
|
||
* Enroll confirms are performed by the application roster manager so
|
||
* anyplace where the application roster manager isn't informed of the
|
||
* enroll we must perform the enroll confirm here in this routine.
|
||
*/
|
||
GCCError CConf::
|
||
AppEnrollRequest
|
||
(
|
||
CAppSap *pAppSap,
|
||
GCCEnrollRequest *pReq,
|
||
GCCRequestTag nReqTag
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
CAppRosterMgr *pAppRosterMgr;
|
||
CAppRosterMgr *pNewAppRosterMgr = NULL; // a must
|
||
EntityID eid, new_eid = GCC_INVALID_EID; // a must
|
||
GCCNodeID nid;
|
||
GCCAppEnrollConfirm aec;
|
||
|
||
DebugEntry(CConf::AppEnrollRequest);
|
||
|
||
TRACE_OUT_EX(ZONE_T120_APP_ROSTER, ("CConf::AppEnrollRequest: "
|
||
"enrolled?=%u\r\n", (UINT) pReq->fEnroll));
|
||
|
||
// If the conference is not established return an error.
|
||
if (! m_fConfIsEstablished)
|
||
{
|
||
WARNING_OUT(("CConf::AppEnrollRequest: CConf not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
goto MyExit;
|
||
}
|
||
|
||
if (! m_RegisteredAppSapList.Find(pAppSap))
|
||
{
|
||
WARNING_OUT(("CConf::AppEnrollRequest: app not registered"));
|
||
rc = GCC_APPLICATION_NOT_REGISTERED;
|
||
goto MyExit;
|
||
}
|
||
|
||
if (pReq->fEnroll)
|
||
{
|
||
m_cEnrollRequests++;
|
||
}
|
||
else
|
||
{
|
||
m_cEnrollRequests--;
|
||
}
|
||
|
||
TRACE_OUT_EX(ZONE_T120_APP_ROSTER, ("CConf::AppEnrollRequest: cEnroll=%d\r\n", m_cEnrollRequests));
|
||
|
||
if (m_cEnrollRequests < 0)
|
||
{
|
||
//
|
||
// LONCHANC: It seems to me that the upper layer does unenroll without
|
||
// enroll first. it happens when someone calls me.
|
||
// We should change this later and have a way to know whether the app
|
||
// already enrolled or not.
|
||
//
|
||
m_cEnrollRequests = 0;
|
||
}
|
||
|
||
// get the node id
|
||
nid = m_pMcsUserObject->GetMyNodeID();
|
||
|
||
/*
|
||
** Is the application enrolling or unenrolling? Here we set up the
|
||
** application roster and APE information if enrolling.
|
||
*/
|
||
if (pReq->fEnroll) // Appplication is enrolling
|
||
{
|
||
TRACE_OUT(("CConf::AppEnrollRequest: Application is Enrolling"));
|
||
|
||
/*
|
||
** First determine if this APE has already enrolled with this
|
||
** conference. If it hasn't we must generate a new EntityID for
|
||
** this APE.
|
||
*/
|
||
rc = GetEntityIDFromAPEList(pAppSap, pReq->pSessionKey, &eid);
|
||
if (rc == GCC_APP_NOT_ENROLLED)
|
||
{
|
||
rc = GenerateEntityIDForAPEList(pAppSap, pReq->pSessionKey, &new_eid);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::AppEnrollRequest: can't generate entity id, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
eid = new_eid;
|
||
m_pAppRegistry->EnrollAPE(eid, pAppSap);
|
||
}
|
||
|
||
/*
|
||
** This takes care of setting up the application roster manager
|
||
** if none exists or it will call the appropriate manager with
|
||
** the enroll.
|
||
*/
|
||
pAppRosterMgr = GetAppRosterManager(pReq->pSessionKey);
|
||
if (pAppRosterMgr == NULL)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
pNewAppRosterMgr = new CAppRosterMgr(
|
||
pReq->pSessionKey,
|
||
NULL,
|
||
m_nConfID,
|
||
m_pMcsUserObject,
|
||
this,
|
||
&rc);
|
||
if (NULL == pNewAppRosterMgr || GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::AppEnrollRequest: can't create app roster mgr, rc=%d", rc));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
goto MyExit;
|
||
}
|
||
|
||
pAppRosterMgr = pNewAppRosterMgr;
|
||
}
|
||
|
||
/*
|
||
** Doing the enroll here ensures that an empty roster
|
||
** manager will not get put in to the roster manager
|
||
** list if the Enroll Fails.
|
||
*/
|
||
rc = pAppRosterMgr->EnrollRequest(pReq, eid, nid, pAppSap);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::AppEnrollRequest: EnrollRequest failed, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** If this is a new roster manager we will append it to
|
||
** the list of roster managers here if no errors occcured.
|
||
*/
|
||
if (pNewAppRosterMgr != NULL)
|
||
{
|
||
m_AppRosterMgrList.Append(pNewAppRosterMgr);
|
||
}
|
||
|
||
/*
|
||
** Here we inform the newly enrolled application of the
|
||
** conductor status if the conference is conductible.
|
||
*/
|
||
if (m_fConfConductible)
|
||
{
|
||
if (m_nConductorNodeID != 0)
|
||
{
|
||
pAppSap->ConductorAssignIndication(m_nConductorNodeID, m_nConfID);
|
||
}
|
||
else
|
||
{
|
||
pAppSap->ConductorReleaseIndication(m_nConfID);
|
||
}
|
||
}
|
||
}
|
||
else // Appplication is unenrolling
|
||
{
|
||
TRACE_OUT(("CConf::AppEnrollRequest: Application is UnEnrolling"));
|
||
|
||
if (pReq->pSessionKey != NULL)
|
||
{
|
||
rc = GetEntityIDFromAPEList(pAppSap, pReq->pSessionKey, &eid);
|
||
if (rc != GCC_NO_ERROR)
|
||
{
|
||
WARNING_OUT(("CConf::AppEnrollRequest: app not enrolled"));
|
||
goto MyExit;
|
||
}
|
||
|
||
pAppRosterMgr = GetAppRosterManager(pReq->pSessionKey);
|
||
if (NULL == pAppRosterMgr)
|
||
{
|
||
WARNING_OUT(("CConf::AppEnrollRequest: app not enrolled"));
|
||
rc = GCC_APP_NOT_ENROLLED;
|
||
goto MyExit;
|
||
}
|
||
|
||
/*
|
||
** UnEnroll this APE from the specified session.
|
||
** Note that the application roster manager will send
|
||
** the enroll confirm.
|
||
*/
|
||
pAppRosterMgr->UnEnrollRequest(pReq->pSessionKey, eid);
|
||
|
||
// UnEnroll this APE from the registry
|
||
m_pAppRegistry->UnEnrollAPE(eid);
|
||
|
||
/*
|
||
** Since this APE is no longer enrolled remove it from
|
||
** the list of APEs.
|
||
*/
|
||
DeleteEnrolledAPE(eid);
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::AppEnrollRequest: null session key"));
|
||
/*
|
||
** Since a null session key was passed in we will go ahead
|
||
** and unenroll all the APEs associated with this sap.
|
||
*/
|
||
RemoveSAPFromAPEList(pAppSap);
|
||
}
|
||
}
|
||
|
||
/*
|
||
** Here we take care of sending the enroll confirm to the application
|
||
** SAP that enrolled. We also flush any roster PDUs and messages that
|
||
** might have been queued up during the enrollment process above. Note
|
||
** that we only send a successful enroll confirm if no errors occured.
|
||
*/
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
/*
|
||
** First we sent the enroll confirm. It is important to send this
|
||
** before the flush so that the node ID and entity ID will be
|
||
** received by a top provider node before the roster is delivered
|
||
** with the applications record in it. This makes it easier on the
|
||
** developer when trying to determine if the enrolled record is in
|
||
** the roster when the roster report is received.
|
||
*/
|
||
aec.nConfID = m_nConfID;
|
||
aec.sidMyself = pReq->pSessionKey->session_id;
|
||
aec.eidMyself = eid;
|
||
aec.nidMyself = nid;
|
||
aec.nResult = GCC_RESULT_SUCCESSFUL;
|
||
aec.nReqTag = nReqTag;
|
||
pAppSap->AppEnrollConfirm(&aec);
|
||
|
||
/*
|
||
** Now we flush all the application roster managers of any PDU data
|
||
** that might have been queued up during enrollment. This also
|
||
** gives the roster managers a chance to deliver roster update if
|
||
** necessary. Note that we build and deliver the high level
|
||
** portion of the PDU here. Since only application roster stuff will be
|
||
** sent in this pdu we must set the pointer to the conference
|
||
** information to NULL so that the encoder wont try to encode it.
|
||
** An error here is considered FATAL in that the conference information
|
||
** base at this node is now corrupted therefore we terminate the
|
||
** conference. Note that we only do the flush here if the start up
|
||
** alarm has expired.
|
||
*/
|
||
rc = AsynchFlushRosterData();
|
||
if (rc != GCC_NO_ERROR)
|
||
{
|
||
ERROR_OUT(("CConf::AppEnrollRequest: can't flush roster data, rc=%d", rc));
|
||
|
||
InitiateTermination((rc == GCC_ALLOCATION_FAILURE) ?
|
||
GCC_REASON_ERROR_LOW_RESOURCES :
|
||
GCC_REASON_ERROR_TERMINATION,
|
||
0);
|
||
goto MyExit;
|
||
}
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR != rc && pReq->fEnroll)
|
||
{
|
||
if (NULL != pNewAppRosterMgr)
|
||
{
|
||
pNewAppRosterMgr->Release();
|
||
}
|
||
|
||
if (new_eid != GCC_INVALID_EID)
|
||
{
|
||
// UnEnroll this APE from the registry
|
||
m_pAppRegistry->UnEnrollAPE(new_eid);
|
||
DeleteEnrolledAPE(new_eid);
|
||
}
|
||
}
|
||
|
||
DebugExitINT(CConf::AppEnrollRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::DisconnectProviderIndication ()
|
||
*
|
||
* Public Function Description
|
||
* This routine is called from the owner object when a
|
||
* Disconnect Provider is received from the MCS interface.
|
||
* Since the owner object has no way of knowing which connections
|
||
* are associated with which conferences it may be possible to
|
||
* receive a disconnect provider for a connection that is not in
|
||
* the conferences list.
|
||
*/
|
||
GCCError CConf::
|
||
DisconnectProviderIndication ( ConnectionHandle connection_handle )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
GCCNodeID nidDisconnected;
|
||
|
||
DebugEntry(CConf::DisconnectProviderIndication);
|
||
|
||
TRACE_OUT(("CConf::DisconnectProviderIndication: connection_handle = %d", connection_handle));
|
||
|
||
// reject any pending join ind response
|
||
ConnectionHandle hConn;
|
||
while (NULL != m_JoinRespNamePresentConnHdlList2.Get(&hConn))
|
||
{
|
||
if (NULL != g_pGCCController)
|
||
{
|
||
g_pGCCController->FailConfJoinIndResponse(0, hConn);
|
||
}
|
||
}
|
||
|
||
// First check for the parent connection going down.
|
||
if (m_hParentConnection == connection_handle)
|
||
{
|
||
TRACE_OUT(("CConf::DisconnectProviderIndication: Connection == PARENT"));
|
||
|
||
/*
|
||
** If the Parent Connection is broken the conference must be
|
||
** terminated since this node no longer has access to the top
|
||
** gcc provider.
|
||
*/
|
||
m_hParentConnection = NULL;
|
||
InitiateTermination ( GCC_REASON_PARENT_DISCONNECTED, 0);
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Now check to see if this connection is associated with an ejected
|
||
** node.
|
||
*/
|
||
nidDisconnected = m_pMcsUserObject->GetUserIDFromConnection(connection_handle);
|
||
|
||
if (m_EjectedNodeConfirmList.Remove(nidDisconnected))
|
||
{
|
||
#ifdef JASPER
|
||
g_pControlSap->ConfEjectUserConfirm(m_nConfID,
|
||
nidDisconnected,
|
||
GCC_RESULT_SUCCESSFUL);
|
||
#endif // JASPER
|
||
}
|
||
|
||
// If this is the convener set its node id back to 0
|
||
if (m_nConvenerNodeID == nidDisconnected)
|
||
m_nConvenerNodeID = 0;
|
||
|
||
// Inform the User Attachment object that another user disconnected
|
||
m_pMcsUserObject->UserDisconnectIndication (nidDisconnected);
|
||
|
||
ASSERT(0 != connection_handle);
|
||
if (m_ConnHandleList.Remove(connection_handle))
|
||
{
|
||
TRACE_OUT(("CConf::DisconnectProviderIndication: Connection = CHILD"));
|
||
|
||
/*
|
||
** If there is a disconnect pending we must send the disconnect
|
||
** confirm here and terminate the conference. Note that in this
|
||
** case, the m_fConfIsEstablished variable was set to FALSE
|
||
** when the Disconnect Request was issued (therefore a terminate
|
||
** indication will not be sent).
|
||
*/
|
||
if (m_ConnHandleList.IsEmpty() && m_fConfDisconnectPending)
|
||
{
|
||
TRACE_OUT(("CConf::DisconnectProviderIndication: conf disconnect confirm"));
|
||
/*
|
||
** First inform the control SAP that this node has successfuly
|
||
** disconnected.
|
||
*/
|
||
g_pControlSap->ConfDisconnectConfirm(m_nConfID, GCC_RESULT_SUCCESSFUL);
|
||
|
||
// Tell the owner object to terminate this conference
|
||
InitiateTermination(GCC_REASON_NORMAL_TERMINATION, m_pMcsUserObject->GetMyNodeID());
|
||
}
|
||
else
|
||
if (m_ConnHandleList.IsEmpty() && m_fConfTerminatePending)
|
||
{
|
||
TRACE_OUT(("CConf::DisconnectProviderIndication: Terminate Request is Completed"));
|
||
|
||
InitiateTermination(m_eConfTerminateReason, m_pMcsUserObject->GetMyNodeID());
|
||
}
|
||
else
|
||
if (m_ConnHandleList.IsEmpty() &&
|
||
((m_eNodeType == TOP_PROVIDER_NODE) ||
|
||
(m_eNodeType == TOP_PROVIDER_AND_CONVENER_NODE)) &&
|
||
(m_eTerminationMethod == GCC_AUTOMATIC_TERMINATION_METHOD))
|
||
{
|
||
/*
|
||
** If nothing is left in our connection list and we are the Top
|
||
** Provider and automatic termination is enabled then terminate
|
||
** the conference.
|
||
*/
|
||
TRACE_OUT(("CConf::DisconnectProviderIndication: AUTOMATIC_TERMINATION"));
|
||
|
||
InitiateTermination( GCC_REASON_NORMAL_TERMINATION, 0);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rc = GCC_INVALID_PARAMETER;
|
||
}
|
||
}
|
||
|
||
DebugExitINT(CConf::DisconnectProviderIndication, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* void ConfRosterInquireRequest()
|
||
*
|
||
* Public Function Description
|
||
* This function is used to obtain a conference roster. The conference
|
||
* roster is delivered to the requesting command target in a Conference
|
||
* Roster inquire confirm.
|
||
*/
|
||
GCCError CConf::
|
||
ConfRosterInquireRequest
|
||
(
|
||
CBaseSap *pSap,
|
||
GCCAppSapMsgEx **ppMsgEx
|
||
)
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
CConfRoster *conference_roster;
|
||
LPWSTR pwszConfDescription = NULL;
|
||
GCCConferenceName conference_name;
|
||
GCCNumericString conference_modifier;
|
||
|
||
DebugEntry(CConf::ConfRosterInquireRequest);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
/*
|
||
** We use the actual conference roster here to build the roster
|
||
** inquire confirm message. Note that the SAP should NOT free this
|
||
** roster.
|
||
*/
|
||
conference_roster = m_pConfRosterMgr->GetConferenceRosterPointer();
|
||
if (conference_roster != NULL)
|
||
{
|
||
GetConferenceNameAndModifier(&conference_name, &conference_modifier);
|
||
if (m_pwszConfDescription != NULL)
|
||
{
|
||
pwszConfDescription= m_pwszConfDescription;
|
||
}
|
||
|
||
pSap->ConfRosterInquireConfirm(m_nConfID,
|
||
&conference_name,
|
||
conference_modifier,
|
||
pwszConfDescription,
|
||
conference_roster,
|
||
GCC_RESULT_SUCCESSFUL,
|
||
ppMsgEx);
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfRosterInquireRequest: conf roster does not exist"));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CConf::ConfRosterInquireRequest: conference not established"));
|
||
rc = GCC_CONFERENCE_NOT_ESTABLISHED;
|
||
}
|
||
|
||
DebugExitINT(CConf:ConfRosterInquireRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::AppRosterInquireRequest()
|
||
*
|
||
* Public Function Description
|
||
* This function is used to obtain a list of application rosters. This
|
||
* list is delivered to the requesting SAP through an Application Roster
|
||
* inquire confirm message.
|
||
*/
|
||
GCCError CConf::
|
||
AppRosterInquireRequest
|
||
(
|
||
PGCCSessionKey session_key,
|
||
CAppRosterMsg **ppAppRosterMsgOut
|
||
)
|
||
{
|
||
GCCError rc;
|
||
BOOL roster_manager_found = FALSE;
|
||
CAppRosterMsg *roster_message = NULL;
|
||
CAppRosterMgr *lpAppRosterMgr;
|
||
|
||
DebugEntry(CConf::AppRosterInquireRequest);
|
||
|
||
if (m_AppRosterMgrList.IsEmpty())
|
||
{
|
||
WARNING_OUT(("CConf::AppRosterInquireRequest: app roster mgr is empty"));
|
||
rc = GCC_NO_SUCH_APPLICATION;
|
||
goto MyExit;
|
||
}
|
||
|
||
// First allocate the application roster message
|
||
DBG_SAVE_FILE_LINE
|
||
roster_message = new CAppRosterMsg();
|
||
if (NULL == roster_message)
|
||
{
|
||
ERROR_OUT(("CConf::AppRosterInquireRequest: can't create app roster msg"));
|
||
rc = GCC_ALLOCATION_FAILURE;
|
||
goto MyExit;
|
||
}
|
||
|
||
rc = GCC_NO_ERROR;
|
||
|
||
m_AppRosterMgrList.Reset();
|
||
if (session_key != NULL)
|
||
{
|
||
while (NULL != (lpAppRosterMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
roster_manager_found = lpAppRosterMgr->IsThisYourSessionKey (session_key);
|
||
if (roster_manager_found)
|
||
{
|
||
rc = lpAppRosterMgr->ApplicationRosterInquire(session_key, roster_message);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
while (NULL != (lpAppRosterMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
rc = lpAppRosterMgr->ApplicationRosterInquire (NULL, roster_message);
|
||
if (rc != GCC_NO_ERROR)
|
||
break;
|
||
}
|
||
}
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR == rc)
|
||
{
|
||
*ppAppRosterMsgOut = roster_message;
|
||
// do not call roster_message->Release() because the sap will call it as needed
|
||
}
|
||
else
|
||
{
|
||
if (NULL != roster_message)
|
||
{
|
||
roster_message->Release();
|
||
}
|
||
}
|
||
|
||
DebugExitINT(CConf::AppRosterInquireRequest, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::FlushOutgoingPDU()
|
||
*
|
||
* Public Function Description
|
||
* This is the heartbeat for the conference object. The conference
|
||
* is responsible for giving the User Attachment object its
|
||
* heartbeat.
|
||
* Return value:
|
||
* TRUE, if there remain un-processed msgs in the CConf message queue
|
||
* FALSE, if all the msgs in the conference msg queue were processed.
|
||
*/
|
||
BOOL CConf::
|
||
FlushOutgoingPDU ( void )
|
||
{
|
||
//GCCError error_value;
|
||
BOOL fFlushMoreData = FALSE;
|
||
|
||
if (m_fConfTerminatePending && m_pConfTerminateAlarm != NULL)
|
||
{
|
||
if (m_pConfTerminateAlarm->IsExpired())
|
||
{
|
||
delete m_pConfTerminateAlarm;
|
||
m_pConfTerminateAlarm = NULL;
|
||
InitiateTermination(m_eConfTerminateReason, m_pMcsUserObject->GetTopNodeID());
|
||
}
|
||
else
|
||
{
|
||
fFlushMoreData = TRUE;
|
||
}
|
||
}
|
||
|
||
if (m_pMcsUserObject != NULL)
|
||
{
|
||
m_pMcsUserObject->CheckEjectedNodeAlarms();
|
||
fFlushMoreData |= m_pMcsUserObject->FlushOutgoingPDU();
|
||
}
|
||
|
||
return fFlushMoreData;
|
||
}
|
||
|
||
|
||
/*
|
||
* BOOL IsConfEstablished ()
|
||
*
|
||
* Public Function Description
|
||
* The conference is established when it is ready to be enrolled
|
||
* with. No application permission to enrolls should be sent until
|
||
* this routine returns TRUE.
|
||
*/
|
||
|
||
|
||
/*
|
||
* BOOL IsConfTopProvider ()
|
||
*
|
||
* Public Function Description
|
||
* Function informs whether this node is the Top Provider of the
|
||
* conference.
|
||
*/
|
||
|
||
|
||
/*
|
||
* GCCNodeID GetTopProvider ()
|
||
*
|
||
* Public Function Description
|
||
* Function returns the GCCNodeID of the Top Provider of the conference.
|
||
*/
|
||
|
||
|
||
|
||
/*
|
||
* BOOL DoesConvenerExists ()
|
||
*
|
||
* Public Function Description
|
||
* This function informs whether or not the convener is still joined to
|
||
* this conference.
|
||
*/
|
||
|
||
|
||
/*
|
||
* LPSTR GetNumericConfName()
|
||
*
|
||
* Public Function Description
|
||
* Returns a pointer to the numeric portion of the conference name. Used
|
||
* for comparisons.
|
||
*/
|
||
|
||
|
||
/*
|
||
* LPWSTR GetTextConfName()
|
||
*
|
||
* Public Function Description
|
||
* Returns a pointer to the text portion of the conference name. Used for
|
||
* comparisons.
|
||
*/
|
||
|
||
|
||
/*
|
||
* LPSTR GetConfModifier()
|
||
*
|
||
* Public Function Description
|
||
* Returns a pointer to the conference name modifier.
|
||
*/
|
||
|
||
|
||
/*
|
||
* LPWSTR GetConfDescription()
|
||
*
|
||
* Public Function Description
|
||
* Returns a pointer to the conference description.
|
||
*/
|
||
|
||
|
||
/*
|
||
* CNetAddrListContainer *GetNetworkAddressList()
|
||
*
|
||
* Public Function Description
|
||
* Returns a pointer to the network address list.
|
||
*/
|
||
|
||
|
||
/*
|
||
* GCCConfID GetConfID()
|
||
*
|
||
* Public Function Description
|
||
* Returns the conference ID.
|
||
*/
|
||
|
||
|
||
/*
|
||
* BOOL IsConfListed()
|
||
*
|
||
* Public Function Description
|
||
* Returns the listed flag.
|
||
*/
|
||
|
||
|
||
/*
|
||
* BOOL IsConfPasswordInTheClear()
|
||
*
|
||
* Public Function Description
|
||
* Returns the password protected flag.
|
||
*/
|
||
|
||
|
||
/*
|
||
* BOOL IsConfLocked()
|
||
*
|
||
* Public Function Description
|
||
* Returns the locked flag.
|
||
*/
|
||
|
||
|
||
/*
|
||
** These routines operate on the m_EnrolledApeEidList2.
|
||
*/
|
||
|
||
/*
|
||
* CConf::GetEntityIDFromAPEList ()
|
||
*
|
||
* Private Function Description
|
||
* This routine determines what the entity id is for the specified APE
|
||
* (note that an APE is defined by its SAP handle and the session key
|
||
* of the session it is enrolled in). If there is no entity ID associated
|
||
* with this APE an error is returned.
|
||
*
|
||
* Formal Parameters:
|
||
* hSap - (i) SAP handle associated with the entity ID being
|
||
* searched for.
|
||
* session_key - (i) Session key associated with the entity ID being
|
||
* searched for.
|
||
* entity_id - (o) The found entity ID is returned here (or zero if
|
||
* none is found).
|
||
*
|
||
* Return Value
|
||
* GCC_NO_ERROR - No error occured.
|
||
* GCC_ALLOCATION_FAILURE - A resource error occured allocating session
|
||
* key data.
|
||
* GCC_APP_NOT_ENROLLED - Entity ID was not found.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
GCCError CConf::
|
||
GetEntityIDFromAPEList
|
||
(
|
||
CAppSap *pAppSap,
|
||
PGCCSessionKey session_key,
|
||
GCCEntityID *pEid
|
||
)
|
||
{
|
||
GCCError rc = GCC_ALLOCATION_FAILURE;
|
||
CSessKeyContainer *pSessKey;
|
||
|
||
*pEid = GCC_INVALID_EID;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pSessKey = new CSessKeyContainer(session_key, &rc);
|
||
if (pSessKey != NULL && rc == GCC_NO_ERROR)
|
||
{
|
||
GCCEntityID eid;
|
||
ENROLLED_APE_INFO *lpEnrAPEInfo;
|
||
|
||
m_EnrolledApeEidList2.Reset();
|
||
while (NULL != (lpEnrAPEInfo = m_EnrolledApeEidList2.Iterate(&eid)))
|
||
{
|
||
if (pAppSap == lpEnrAPEInfo->pAppSap &&
|
||
*pSessKey == *lpEnrAPEInfo->session_key)
|
||
{
|
||
*pEid = eid;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (*pEid == GCC_INVALID_EID)
|
||
{
|
||
TRACE_OUT(("CConf::GetEntityIDFromAPEList: App NOT Enrolled"));
|
||
rc = GCC_APP_NOT_ENROLLED;
|
||
}
|
||
}
|
||
|
||
// Free up the temporary session key.
|
||
if (NULL != pSessKey)
|
||
{
|
||
pSessKey->Release();
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::GenerateEntityIDForAPEList ()
|
||
*
|
||
* Private Function Description
|
||
* This function is responsible for generating a unqiue entity ID for
|
||
* the specified APE.
|
||
*
|
||
* Formal Parameters:
|
||
* hSap - (i) SAP handle associated with the entity ID being
|
||
* generated.
|
||
* session_key - (i) Session key associated with the entity ID being
|
||
* generated.
|
||
* entity_id - (o) The generated entity ID is returned here.
|
||
*
|
||
* Return Value
|
||
* GCC_NO_ERROR - No error occured.
|
||
* GCC_ALLOCATION_FAILURE - A resource error occured.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
GCCError CConf::
|
||
GenerateEntityIDForAPEList
|
||
(
|
||
CAppSap *pAppSap,
|
||
PGCCSessionKey session_key,
|
||
GCCEntityID *pEid
|
||
)
|
||
{
|
||
GCCError rc = GCC_ALLOCATION_FAILURE;
|
||
CSessKeyContainer *pSessKey = NULL; // a must
|
||
EntityID eidOriginal;
|
||
ENROLLED_APE_INFO *enrolled_ape_info = NULL; // a must
|
||
|
||
/*
|
||
** First find an entity id that has not been used. If all of the IDs
|
||
** are in use we return an allocation failure.
|
||
*/
|
||
*pEid = GCC_INVALID_EID;
|
||
eidOriginal = m_nAPEEntityID;
|
||
while (TRUE)
|
||
{
|
||
if (++m_nAPEEntityID != GCC_INVALID_EID)
|
||
{
|
||
if (NULL == m_EnrolledApeEidList2.Find(m_nAPEEntityID))
|
||
{
|
||
// the new entity ID does not exist. job is done.
|
||
*pEid = m_nAPEEntityID;
|
||
break;
|
||
}
|
||
|
||
if (m_nAPEEntityID == eidOriginal)
|
||
{
|
||
ERROR_OUT(("CConf::GenerateEntityIDForAPEList: use up all entity IDs"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
}
|
||
}
|
||
|
||
ASSERT(GCC_INVALID_EID != *pEid);
|
||
|
||
/*
|
||
** Now if no errors occured we will create the enrolled APE info structure
|
||
** that will be stored in the enrolled APE list.
|
||
*/
|
||
//
|
||
// LONCHANC: We should avoid this memory allocation. ENROLLED_APE_INFO has only 2 dwords!
|
||
//
|
||
DBG_SAVE_FILE_LINE
|
||
enrolled_ape_info = new ENROLLED_APE_INFO;
|
||
if (NULL == enrolled_ape_info)
|
||
{
|
||
ERROR_OUT(("CConf::GenerateEntityIDForAPEList: can't create ENROLLED_APE_INFO"));
|
||
ASSERT(GCC_ALLOCATION_FAILURE == rc);
|
||
goto MyExit;
|
||
}
|
||
|
||
enrolled_ape_info->pAppSap = pAppSap;
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
pSessKey = new CSessKeyContainer(session_key, &rc);
|
||
if (pSessKey != NULL && rc == GCC_NO_ERROR)
|
||
{
|
||
enrolled_ape_info->session_key = pSessKey;
|
||
m_EnrolledApeEidList2.Append(*pEid, enrolled_ape_info);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
delete enrolled_ape_info;
|
||
if (NULL != pSessKey)
|
||
{
|
||
pSessKey->Release();
|
||
}
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/*
|
||
* CConf::RemoveSAPFromAPEList ()
|
||
*
|
||
* Private Function Description
|
||
* This routine takes care of removing all the references to a single
|
||
* sap from the m_EnrolledApeEidList2. It is also responsible for unenrolling
|
||
* all of these APEs from the appropriate Application SAPs.
|
||
*
|
||
* Formal Parameters:
|
||
* hSap - (i) SAP handle to remove and unenroll.
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
void CConf::
|
||
RemoveSAPFromAPEList ( CAppSap *pAppSap )
|
||
{
|
||
GCCEntityID eid;
|
||
ENROLLED_APE_INFO *lpEnrAPEInfo;
|
||
|
||
/*
|
||
** We make a temporary copy of the list here so that we can remove
|
||
** members from it while we are iterating on it.
|
||
*/
|
||
while (NULL != (lpEnrAPEInfo = GetEnrolledAPEbySap(pAppSap, &eid)))
|
||
{
|
||
CAppRosterMgr *lpAppRosterMgr;
|
||
/*
|
||
** Here we remove the entities associated with this application
|
||
** from any application rosters it is enrolled in.
|
||
*/
|
||
m_AppRosterMgrList.Reset();
|
||
while (NULL != (lpAppRosterMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
TRACE_OUT(("CConf::RemoveSAPFromAPEList: remove entity = %d", (int) eid));
|
||
lpAppRosterMgr->RemoveEntityReference(eid);
|
||
}
|
||
|
||
/*
|
||
** We must remove any references to this SAP from the
|
||
** registry so that any outstanding request by this SAP
|
||
** will not be processed.
|
||
*/
|
||
m_pAppRegistry->UnEnrollAPE(eid);
|
||
|
||
/*
|
||
** Since this APE is no longer enrolled remove it from
|
||
** the list of APEs.
|
||
*/
|
||
DeleteEnrolledAPE(eid);
|
||
}
|
||
}
|
||
|
||
/*
|
||
* CConf::DoesSAPHaveEnrolledAPE ()
|
||
*
|
||
* Private Function Description
|
||
* This routine is responsible for determining if there is a single
|
||
* (or multiple) APEs enrolled through the specified SAP handle.
|
||
*
|
||
* Formal Parameters:
|
||
* sap_handle - (i) SAP handle of SAP being checked.
|
||
*
|
||
* Return Value
|
||
* TRUE - If SAP does have an enrolled APE.
|
||
* FALSE - If SAP does not have an enrolled APE.
|
||
*
|
||
* Side Effects
|
||
* None.
|
||
*
|
||
* Caveats
|
||
* None.
|
||
*/
|
||
|
||
|
||
ENROLLED_APE_INFO *CConf::
|
||
GetEnrolledAPEbySap
|
||
(
|
||
CAppSap *pAppSap,
|
||
GCCEntityID *pEid
|
||
)
|
||
{
|
||
ENROLLED_APE_INFO *pEnrAPEInfo;
|
||
GCCEntityID eid;
|
||
|
||
m_EnrolledApeEidList2.Reset();
|
||
while (NULL != (pEnrAPEInfo = m_EnrolledApeEidList2.Iterate(&eid)))
|
||
{
|
||
if (pAppSap == pEnrAPEInfo->pAppSap)
|
||
{
|
||
if (NULL != pEid)
|
||
{
|
||
*pEid = eid;
|
||
}
|
||
return pEnrAPEInfo;
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
void CConf::
|
||
DeleteEnrolledAPE ( EntityID nEntityID )
|
||
{
|
||
ENROLLED_APE_INFO *lpEnrAPEInfo;
|
||
|
||
if (NULL != (lpEnrAPEInfo = m_EnrolledApeEidList2.Remove(nEntityID)))
|
||
{
|
||
if (NULL != lpEnrAPEInfo->session_key)
|
||
{
|
||
lpEnrAPEInfo->session_key->Release();
|
||
}
|
||
delete lpEnrAPEInfo;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* GCCError FlushRosterData()
|
||
*
|
||
* Private Function Description
|
||
* This routine flushes all the application roster managers of any PDU data
|
||
* that might be queued up. This also gives the roster managers a chance
|
||
* to deliver roster update if necessary. Note that we build and deliver
|
||
* the high level portion of the PDU here. Since only application roster
|
||
* stuff will be sent in this pdu we must set the pointer to the conference
|
||
* information to NULL so that the encoder wont try to encode it.
|
||
*/
|
||
GCCError CConf::
|
||
AsynchFlushRosterData ( void )
|
||
{
|
||
if (NULL != g_pControlSap)
|
||
{
|
||
AddRef();
|
||
::PostMessage(g_pControlSap->GetHwnd(), CONF_FLUSH_ROSTER_DATA, 0, (LPARAM) this);
|
||
}
|
||
|
||
return GCC_NO_ERROR;
|
||
}
|
||
|
||
void CConf::
|
||
WndMsgHandler ( UINT uMsg )
|
||
{
|
||
if (CONF_FLUSH_ROSTER_DATA == uMsg)
|
||
{
|
||
FlushRosterData();
|
||
|
||
//
|
||
// We AddRef while posting the message.
|
||
//
|
||
Release();
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("WndMsgHandler: invalid msg=%u", uMsg));
|
||
}
|
||
}
|
||
|
||
GCCError CConf::
|
||
FlushRosterData ( void )
|
||
{
|
||
GCCError rc = GCC_NO_ERROR;
|
||
|
||
DebugEntry(CConf::FlushRosterData);
|
||
|
||
if (m_fConfIsEstablished)
|
||
{
|
||
GCCPDU gcc_pdu;
|
||
CAppRosterMgrList RosterMgrDeleteList;
|
||
CAppRosterMgr *lpAppRosterMgr;
|
||
|
||
gcc_pdu.choice = INDICATION_CHOSEN;
|
||
gcc_pdu.u.indication.choice = ROSTER_UPDATE_INDICATION_CHOSEN;
|
||
gcc_pdu.u.indication.u.roster_update_indication.refresh_is_full = FALSE;
|
||
gcc_pdu.u.indication.u.roster_update_indication.application_information= NULL;
|
||
|
||
// First get any CConf Roster PDU data that exists.
|
||
rc = m_pConfRosterMgr->FlushRosterUpdateIndication(
|
||
&gcc_pdu.u.indication.u.roster_update_indication.node_information);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::FlushRosterData: can't flush conf roster update, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
if (IsReadyToSendAppRosterUpdate())
|
||
{
|
||
PSetOfApplicationInformation *ppSetOfAppInfo;
|
||
PSetOfApplicationInformation pNextSetOfInfo;
|
||
|
||
// Set up the pointer to the first application information.
|
||
ppSetOfAppInfo = &gcc_pdu.u.indication.u.roster_update_indication.application_information;
|
||
|
||
/*
|
||
** Here we iterate through all the application roster managers
|
||
** giving each a chance to append their roster updates to the
|
||
** roster update PDU and to deliver any necessary roster update
|
||
** messages.
|
||
*/
|
||
m_AppRosterMgrList.Reset();
|
||
while (NULL != (lpAppRosterMgr = m_AppRosterMgrList.Iterate()))
|
||
{
|
||
pNextSetOfInfo = lpAppRosterMgr->FlushRosterUpdateIndication(ppSetOfAppInfo, &rc);
|
||
if (GCC_NO_ERROR != rc)
|
||
{
|
||
ERROR_OUT(("CConf::FlushRosterData: can't flush app roster update, rc=%d", rc));
|
||
goto MyExit;
|
||
}
|
||
|
||
if (NULL != pNextSetOfInfo)
|
||
{
|
||
ppSetOfAppInfo = &pNextSetOfInfo->next;
|
||
}
|
||
|
||
/*
|
||
** Here we add the application roster manager to the list of
|
||
** managers to delete. They we be deleted and removed from the
|
||
** roster manager list below after the PDU is delivered.
|
||
*/
|
||
if (lpAppRosterMgr->IsEmpty())
|
||
{
|
||
m_AppRosterMgrList.Remove(lpAppRosterMgr);
|
||
RosterMgrDeleteList.Append(lpAppRosterMgr);
|
||
}
|
||
}
|
||
} // if ready-to-send-app-roster-update
|
||
else
|
||
{
|
||
TRACE_OUT(("CConf::FlushRosterData: not ready to send app roster update"));
|
||
TRACE_OUT(("cApps=%u, m_cEnrollRequests=%u", m_RegisteredAppSapList.GetCount(), m_cEnrollRequests));
|
||
}
|
||
|
||
/*
|
||
** Here, if there are no errors and there is actual application
|
||
** information, we go ahead and send out the roster update.
|
||
*/
|
||
if (NULL != gcc_pdu.u.indication.u.roster_update_indication.
|
||
application_information
|
||
||
|
||
NODE_NO_CHANGE_CHOSEN != gcc_pdu.u.indication.u.roster_update_indication.
|
||
node_information.node_record_list.choice)
|
||
{
|
||
TRACE_OUT(("CConf::FlushRosterData: sending roster update indication to mcs"));
|
||
m_pMcsUserObject->RosterUpdateIndication(
|
||
&gcc_pdu,
|
||
IsConfTopProvider() ? FALSE : TRUE);
|
||
}
|
||
|
||
/*
|
||
** Here we cleanup any empty roster managers. Note that we must do this
|
||
** after delivering the PDU to avoid deleting a roster manager before
|
||
** using data associated with it (data obtained in the flush).
|
||
*/
|
||
RosterMgrDeleteList.DeleteList();
|
||
} // if m_fConfIsEstablished
|
||
|
||
ASSERT(GCC_NO_ERROR == rc);
|
||
|
||
MyExit:
|
||
|
||
DebugExitINT(CConf::FlushRosterData, rc);
|
||
return rc;
|
||
}
|
||
|
||
|
||
|
||
#define MIN_REGISTERED_APPS 2
|
||
|
||
BOOL CConf::
|
||
IsReadyToSendAppRosterUpdate ( void )
|
||
{
|
||
if (m_fFirstAppRosterSent)
|
||
{
|
||
TRACE_OUT_EX(ZONE_T120_APP_ROSTER, ("CConf::IsReadyToSendAppRosterUpdate: "
|
||
"YES <first one sent>\r\n"));
|
||
return TRUE;
|
||
}
|
||
|
||
BOOL fRet = TRUE;
|
||
|
||
if (NULL != m_pConfStartupAlarm &&
|
||
m_pConfStartupAlarm->IsExpired())
|
||
{
|
||
TRACE_OUT_EX(ZONE_T120_APP_ROSTER, ("CConf::IsReadyToSendAppRosterUpdate: "
|
||
"YES <alarm expired>\r\n"));
|
||
// fRet = TRUE;
|
||
}
|
||
else
|
||
{
|
||
UINT cApps = m_RegisteredAppSapList.GetCount();
|
||
if (cApps >= MIN_REGISTERED_APPS &&
|
||
(int) cApps <= m_cEnrollRequests)
|
||
{
|
||
TRACE_OUT_EX(ZONE_T120_APP_ROSTER, ("CConf::IsReadyToSendAppRosterUpdate: "
|
||
"YES <cApp=%u, cEnroll=%d>\r\n", cApps, m_cEnrollRequests));
|
||
// fRet = TRUE;
|
||
}
|
||
else
|
||
{
|
||
TRACE_OUT_EX(ZONE_T120_APP_ROSTER, ("CConf::IsReadyToSendAppRosterUpdate: "
|
||
"NO <cApp=%u, cEnroll=%d>\r\n", cApps, m_cEnrollRequests));
|
||
fRet = FALSE;
|
||
}
|
||
}
|
||
|
||
if (fRet)
|
||
{
|
||
m_fFirstAppRosterSent = TRUE;
|
||
delete m_pConfStartupAlarm;
|
||
m_pConfStartupAlarm = NULL;
|
||
}
|
||
|
||
return fRet;
|
||
}
|
||
|
||
|
||
// look for this node ID in the roster's record set.
|
||
BOOL CConf::
|
||
IsThisNodeParticipant ( GCCNodeID nid )
|
||
{
|
||
return ((NULL != m_pConfRosterMgr) ?
|
||
m_pConfRosterMgr->IsThisNodeParticipant(nid) :
|
||
FALSE);
|
||
}
|
||
|
||
|
||
|
||
void CConfList::
|
||
DeleteList ( void )
|
||
{
|
||
CConf *pConf;
|
||
while (NULL != (pConf = Get()))
|
||
{
|
||
pConf->Release();
|
||
}
|
||
}
|
||
|
||
|
||
void CConfList2::
|
||
DeleteList ( void )
|
||
{
|
||
CConf *pConf;
|
||
while (NULL != (pConf = Get()))
|
||
{
|
||
pConf->Release();
|
||
}
|
||
}
|
||
|
||
|
||
|