#include "precomp.h" DEBUG_FILEZONE(ZONE_T120_GCCNC); /* * mcsuser.cpp * * Copyright (c) 1995 by DataBeam Corporation, Lexington, KY * * Abstract: * This is the implemntation file for the MCSUser class. It implements * functions responsible for encoding out bound indirect conference * join request and response PDUs, and also Send user ID Requests. All * these PDUs are encapsulated in user data field of MCSSendDataRequest. * Also this file implements functions that are responsible for decoding * incoming indications and confirm PDUs which are encapsulated in the * user data field of MCSSendDataIndication. Functions responsible for * joining different channels are also implemented in this module. * * SEE THE INTERFACE FILE FOR A MORE DETAILED DESCRIPTION OF THIS CLASS. * * Private Instance Variables * m_pMCSSap * This is the MCS User handle handed back from the MCS Attache User * Request. * m_nidMyself * The is the MCS User ID returned in the Attach User Confirm. This * is also refered to as the Node ID with in GCC. * m_nidTopProvider * This holds the MCS User ID (or Node ID) for the top Provider. * m_nidParent * This holds the MCS User ID (or Node ID) for this nodes parent node. * m_fEjectionPending * This flag indicates if an ejection of this node is pending. * m_eEjectReason * This variable holds the reason for ejection until the eject * indication can be delivered after all child nodes have disconnected. * m_pOwnerConf * Pointer to the object that will receive all the owner callbacks * from the user object (typically the conference object). * m_ChannelJoinedFlags * A structure of flags used to keep up with creation state machine. * Basically, it keeps up with which channels have been joined and * which ones have not. * m_ChildUidConnHdlList2 * Keeps mapping of child Node IDs to child logical connection * handles. * m_OutgoingPDUQueue * This is a rogue wave list used to queue up all outgoing PDUs. * m_ConfJoinResponseList2 * This rogue wave list holds information needed to send back in a join * response after the local node controller responds. * m_EjectedNodeAlarmList2 * This list holds alarm objects for all the nodes that have been * ejected and are directly connected to this node. The alarm is * used to disconnect any misbehaving nodes that do not disconnect * after the EJECTED_NODE_TIMER_DURATION. * m_EjectedNodeList * This list keeps up with nodes that have been ejected but are NOT * directly connected to this node. We save these nodes so that * a correct reason for disconnecting (user ejected) can be issued * when the detch user indication comes in. * * Author: * blp */ #include "mcsuser.h" #include "mcsdllif.h" #include "ogcccode.h" #include "conf.h" #include "translat.h" #include "gcontrol.h" // Static Channel and Token ID definitions used by the MCS user object. #define BROADCAST_CHANNEL_ID 1 #define CONVENER_CHANNEL_ID 2 #define CONDUCTOR_TOKEN_ID 1 // Time given to allow an ejected node to disconnect before it is disconnected #define EJECTED_NODE_TIMER_DURATION 10000 // Duration in milliseconds 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; /* * MCSUser () * * Public Function Description * This is the MCSUser object constructor. It is responsible for * initializing all the instance variables used by this class. The * constructor is responsible for establishing the user attachment to * the MCS domain defined by the conference ID. It also kicks off the * process of joining all the appropriate channels. */ MCSUser:: MCSUser(CConf *pConf, GCCNodeID nidTopProvider, GCCNodeID nidParent, PGCCError return_value) : CRefCount(MAKE_STAMP_ID('M','U','s','r')), m_ChildUidConnHdlList2(), m_EjectedNodeAlarmList2(), m_EjectedNodeList(), m_pConf(pConf), m_nidTopProvider(nidTopProvider), m_nidParent(nidParent), m_nidMyself(NULL), m_fEjectionPending(FALSE) { MCSError mcs_rc; GCCConfID nConfID = pConf->GetConfID(); // No channels are joined initially m_ChannelJoinedFlags.user_channel_joined = FALSE; m_ChannelJoinedFlags.broadcast_channel_joined = FALSE; m_ChannelJoinedFlags.convener_channel_joined = FALSE; m_ChannelJoinedFlags.channel_join_error = FALSE; mcs_rc = g_pMCSIntf->AttachUserRequest(&nConfID, &m_pMCSSap, this); if (MCS_NO_ERROR != mcs_rc) { WARNING_OUT(("MCSUser::MCSUser: Failure in attach user req, ")); *return_value = GCC_FAILURE_ATTACHING_TO_MCS; } else { *return_value = GCC_NO_ERROR; } } /* * ~MCSUser () * * Public Function Description * This is the user destructor. It takes care of leaving channels * joined by the user object. Also it detaches the user attachment * with MCS by issuing a detach user request. */ MCSUser::~MCSUser(void) { // Clean up the Ejected Node Alarm List PAlarm lpAlarm; while (NULL != (lpAlarm = m_EjectedNodeAlarmList2.Get())) { delete lpAlarm; } if(m_ChannelJoinedFlags.user_channel_joined) { g_pMCSIntf->ChannelLeaveRequest(m_nidMyself, m_pMCSSap); } if(m_ChannelJoinedFlags.broadcast_channel_joined) { g_pMCSIntf->ChannelLeaveRequest(BROADCAST_CHANNEL_ID, m_pMCSSap); } if(m_ChannelJoinedFlags.convener_channel_joined) { g_pMCSIntf->ChannelLeaveRequest(CONVENER_CHANNEL_ID, m_pMCSSap); } // Empty the queue of all PDUs SEND_DATA_REQ_INFO *pReqInfo; m_OutgoingPDUQueue.Reset(); while (NULL != (pReqInfo = m_OutgoingPDUQueue.Iterate())) { pReqInfo->packet->Unlock(); delete pReqInfo; } g_pMCSIntf->DetachUserRequest(m_pMCSSap, this); } /* * UINT ProcessAttachUserConfirm () * * Private Function Description * This function is called when the user object gets an attach user * confirm from MCS in response to an attach user request made by the * user object in it's constructor. The function checks the result * indicated in the confirm. If the result is a successful attachment, then * different channels depending upon the type of the provider, are joined. * Also this function reports failures in attach user (as indicated by * result in attach user confirm) and channel joins, to the conference * through an owner callback. * * Formal Parameters: * result - (i) Result of the attach user request. * user_id - (i) This nodes user or Node ID if successful result. * * Return Value * MCS_NO_ERROR - No error is always returned. * * Side Effects * None. * * Caveats * None. */ UINT MCSUser::ProcessAttachUserConfirm(Result result, UserID user_id) { UINT rc; if (result == RESULT_SUCCESSFUL) { m_nidMyself = user_id; /* ** After the attach confirm is received we go ahead and join the ** appropriate channel based on the conf node type. If this ** node is the yop provider we also set up the top provider user id, ** otherwise this gets set up in the constructor. */ switch (m_pConf->GetConfNodeType()) { case TOP_PROVIDER_NODE: m_nidTopProvider = m_nidMyself; rc = JoinUserAndBroadCastChannels(); break; case JOINED_CONVENER_NODE: case CONVENER_NODE: rc = JoinUserAndBroadCastChannels(); if(rc == MCS_NO_ERROR) { rc = JoinConvenerChannel(); } break; case TOP_PROVIDER_AND_CONVENER_NODE: m_nidTopProvider = m_nidMyself; rc = JoinUserAndBroadCastChannels(); if(rc == MCS_NO_ERROR) { rc = JoinConvenerChannel(); } break; case JOINED_NODE: case INVITED_NODE: rc = JoinUserAndBroadCastChannels(); break; default: ERROR_OUT(("User::ProcessAttachUserConfirm: Bad Node Type, %u", (UINT) m_pConf->GetConfNodeType())); break; } if (rc != MCS_NO_ERROR) { /* * ChannelJoinRequestFailed at some level in MCS * So this message tells the conferenceabout this * failure. Conference will delete the user object * as a result of this */ m_pConf->ProcessUserCreateConfirm(USER_CHANNEL_JOIN_FAILURE, m_nidMyself); } } else { /* * Attach user request failed as indicated by the result field in the * confirm message, because of any of the following causes: * congested, domain disconnected, no such domain, too many channels, * too many users, unspecified failure. In this case the user object * just sends the conference a GCC_USER_ATTACH_FAILURE ( to be defined * in command target.h) , which causes * the conference object to delete the user attachment. * UserCreateConfirm message is not corresponding exectly to a single * primitive. */ WARNING_OUT(("MCSUser::ProcessAttachUserConfirm: ATTACH FAILED")); m_pConf->ProcessUserCreateConfirm(USER_ATTACH_FAILURE, m_nidMyself); } return (MCS_NO_ERROR); } /* * MCSError JoinUserAndBroadCastChannels() * * Private Function Description * This function is called by user object when it gets a successful * attach user confrim, to join user id and broadcast channels. * If the channel join requests fail, it returns the appropriate MCS * Error. * * Formal Parameters: * None. * * Return Value * See return values for mcs channel jon request. * * Side Effects * None. * * Caveats * None. */ MCSError MCSUser::JoinUserAndBroadCastChannels() { MCSError rc; rc = g_pMCSIntf->ChannelJoinRequest(m_nidMyself, m_pMCSSap); if(rc == MCS_NO_ERROR) { rc = g_pMCSIntf->ChannelJoinRequest(BROADCAST_CHANNEL_ID, m_pMCSSap); } return (rc); } /* * MCSError JoinUserAndBroadCastChannels() * * Private Function Description * This function is called by user object of a convener gcc provider * when it gets a successful attach user confrim, to join convener * channel. If the channel join requests fail, it returns the appropriate * MCS Error. * * Formal Parameters: * None. * * Return Value * See return values for mcs channel jon request. * * Side Effects * None. * * Caveats * None. */ MCSError MCSUser::JoinConvenerChannel() { return g_pMCSIntf->ChannelJoinRequest(CONVENER_CHANNEL_ID, m_pMCSSap); } /* * UINT ProcessChannelJoinConfirm() * * Private Function Description * This function is called when the user object gets an channel join * confirm from MCS in response to channel join requests made by the * user object. If a channel is joined successfully as indicated by * the result in the confirm, a channel joined flag corresponding to * that channel id is set. This flag indicates as to which channels a * user object is joined at any given time. Also after setting this * flag the functions checks to see if all tke required channels based * on the type of gcc provider, are joined. If all required channels are * joined the conference object is informaed about it via an owner call- * back (USER_CREATE_CONFIRM). * * Formal Parameters: * result - (i) Result of the channel join request. * channel_id - (i) Channel ID that this confirm pertains to. * * Return Value * MCS_NO_ERROR is always returned. * * Side Effects * None. * * Caveats * None. */ UINT MCSUser::ProcessChannelJoinConfirm(Result result, ChannelID channel_id) { if (m_ChannelJoinedFlags.channel_join_error == FALSE) { if (result == RESULT_SUCCESSFUL) { if( channel_id == m_nidMyself) { m_ChannelJoinedFlags.user_channel_joined = TRUE; } else { switch (channel_id) { case CONVENER_CHANNEL_ID: m_ChannelJoinedFlags.convener_channel_joined = TRUE; break; case BROADCAST_CHANNEL_ID: m_ChannelJoinedFlags.broadcast_channel_joined = TRUE; break; } } /* ** If all the channels are joined we inform the owner object that ** the user object was successfully created. */ if (AreAllChannelsJoined()) { m_pConf->ProcessUserCreateConfirm(USER_RESULT_SUCCESSFUL, m_nidMyself); } } else { WARNING_OUT(("MCSUser::ProcessChannelJoinConfirm: Error joining channel, result=%u", (UINT) result)); m_ChannelJoinedFlags.channel_join_error = TRUE ; m_pConf->ProcessUserCreateConfirm(USER_CHANNEL_JOIN_FAILURE, m_nidMyself); } } return (MCS_NO_ERROR); } /* * BOOL AreAllChannelsJoined() * * Public Function Description * This function is called to check if all tke required channels based * on the type of gcc provider, are joined. It returns true if all * required channels are joined and false otherwise. This function uses * different channel joined flags to check which channels the given user * object is joined to. * * Formal Parameters: * None. * * Return Value * TRUE - If all channels are joined. * FALSE - If all the channels are not joined. * * Side Effects * None. * * Caveats * None. */ BOOL MCSUser::AreAllChannelsJoined(void) { BOOL rc = FALSE; switch (m_pConf->GetConfNodeType()) { case TOP_PROVIDER_NODE: if ((m_ChannelJoinedFlags.user_channel_joined) && (m_ChannelJoinedFlags.broadcast_channel_joined)) { rc = TRUE; } break; case JOINED_CONVENER_NODE: case CONVENER_NODE: if ((m_ChannelJoinedFlags.convener_channel_joined) && (m_ChannelJoinedFlags.user_channel_joined) && (m_ChannelJoinedFlags.broadcast_channel_joined)) { rc = TRUE; } break; case TOP_PROVIDER_AND_CONVENER_NODE: if ((m_ChannelJoinedFlags.convener_channel_joined) && (m_ChannelJoinedFlags.user_channel_joined) && (m_ChannelJoinedFlags.broadcast_channel_joined)) { rc = TRUE; } break; case JOINED_NODE: case INVITED_NODE: if( (m_ChannelJoinedFlags.user_channel_joined) && (m_ChannelJoinedFlags.broadcast_channel_joined)) { rc = TRUE; } break; } return rc; } /* * void SendUserIDRequest() * * Public Function Description: * This request originates from the conference object. Conference object * sends the sequence number obtained in the conference create confirm * or conference join confirm to the parent GCC provider on the parent * gcc provider's UserId channel. The pdu is encoded here and is * queued to be sent during the next heartbeat. */ void MCSUser::SendUserIDRequest(TagNumber tag_number) { PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; /* ** Fill in the UserIDIndication pdu structure to be passed in the ** constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = USER_ID_INDICATION_CHOSEN; gcc_pdu.u.indication.u.user_id_indication.tag = tag_number; /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidParent, TOP_PRIORITY, FALSE); } else { ResourceFailureHandler(); } } /* * GCCError ConferenceJoinRequest() * * Public Function Description: * This call is made by the conference object of the intermediate node * to forward the conference join request over to the top provider. This * function encodes the conference join request pdu and queues it to be * sent in the next heartbeat. * * Caveats * The connection handle is used here for a TAG and should be passed back * to the owner object when the join response comes in. */ GCCError MCSUser::ConferenceJoinRequest( CPassword *convener_password, CPassword *password_challenge, LPWSTR pwszCallerID, CUserDataListContainer *user_data_list, ConnectionHandle connection_handle) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = CONFERENCE_JOIN_REQUEST_CHOSEN; gcc_pdu.u.request.u.conference_join_request.tag = (TagNumber)connection_handle; gcc_pdu.u.request.u.conference_join_request.bit_mask = TAG_PRESENT; // Insert the convener password into the ASN.1 structure if (convener_password != NULL) { rc = convener_password->GetPasswordSelectorPDU( &gcc_pdu.u.request.u.conference_join_request.cjrq_convener_password); if (rc == GCC_NO_ERROR) { gcc_pdu.u.request.u.conference_join_request.bit_mask |= CJRQ_CONVENER_PASSWORD_PRESENT; } } // Insert the password challenge into the ASN.1 structure if (( password_challenge != NULL ) && (rc == GCC_NO_ERROR)) { rc = password_challenge->GetPasswordChallengeResponsePDU ( &gcc_pdu.u.request.u.conference_join_request. cjrq_password); if (rc == GCC_NO_ERROR) { gcc_pdu.u.request.u.conference_join_request.bit_mask |= CJRQ_PASSWORD_PRESENT; } } // Insert the caller identifier into the ASN.1 structure UINT cchCallerID = ::My_strlenW(pwszCallerID); if ((cchCallerID != 0 ) && (rc == GCC_NO_ERROR)) { gcc_pdu.u.request.u.conference_join_request.cjrq_caller_id.value = pwszCallerID; gcc_pdu.u.request.u.conference_join_request.cjrq_caller_id.length = cchCallerID; gcc_pdu.u.request.u.conference_join_request.bit_mask |= CJRQ_CALLER_ID_PRESENT; } // Insert the user data into the ASN.1 structure if (( user_data_list != NULL ) && (rc == GCC_NO_ERROR)) { rc = user_data_list->GetUserDataPDU ( &gcc_pdu.u.request.u.conference_join_request.cjrq_user_data); if (rc == GCC_NO_ERROR) { gcc_pdu.u.request.u.conference_join_request.bit_mask |= CJRQ_USER_DATA_PRESENT; } } if (rc == GCC_NO_ERROR) { DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, TOP_PRIORITY, FALSE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } // Cleanup after any errors if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } return rc; } /* * GCCError SendConferenceLockRequest() * * Public Function Description: * This function is invoked by the owner object to send a conference lock * request PDU to the top provider. */ GCCError MCSUser::SendConferenceLockRequest() { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = CONFERENCE_LOCK_REQUEST_CHOSEN; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConferenceLockResponse() * * Public Function Description: * This function is invoked by the owner object to send a conference lock * response PDU to the requesting node. */ GCCError MCSUser::SendConferenceLockResponse ( UserID source_node, GCCResult result) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = CONFERENCE_LOCK_RESPONSE_CHOSEN; gcc_pdu.u.response.u.conference_lock_response.result = ::TranslateGCCResultToLockResult(result); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, source_node, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConferenceUnlockRequest() * * Public Function Description: * This function is invoked by the owner object to send a conference unlock * request PDU to the top provider. */ GCCError MCSUser::SendConferenceUnlockRequest () { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = CONFERENCE_UNLOCK_REQUEST_CHOSEN; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConferenceUnlockResponse() * * Public Function Description: * This function is invoked by the owner object to send a conference unlock * response PDU to the requesting node. */ GCCError MCSUser::SendConferenceUnlockResponse ( UserID source_node, GCCResult result) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = CONFERENCE_UNLOCK_RESPONSE_CHOSEN; gcc_pdu.u.response.u.conference_unlock_response.result = ::TranslateGCCResultToUnlockResult(result); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, source_node, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConferenceLockIndication() * * Public Function Description: * This function is invoked by the owner object of the top provider * to send a conference lock indication PDU to one or all other nodes * that are registered in the conference. */ GCCError MCSUser::SendConferenceLockIndication( BOOL uniform_send, UserID source_node) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_LOCK_INDICATION_CHOSEN; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue( packet, uniform_send ? BROADCAST_CHANNEL_ID : source_node, HIGH_PRIORITY, uniform_send); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConferenceUnlockIndication() * * Public Function Description: * This function is invoked by the owner object of the top provider * to send a conference unlock indication PDU to one or all other nodes * that are registered in the conference. */ GCCError MCSUser::SendConferenceUnlockIndication( BOOL uniform_send, UserID source_node) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_UNLOCK_INDICATION_CHOSEN; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue( packet, uniform_send ? BROADCAST_CHANNEL_ID : source_node, HIGH_PRIORITY, uniform_send); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /******************************* Registry Calls ******************************/ /* * void RegistryRegisterChannelRequest() * * Public Function Description: * This routine is used when an APE wishes to register a channel in * the application registry. */ void MCSUser::RegistryRegisterChannelRequest( CRegKeyContainer *registry_key_data, ChannelID channel_id, EntityID entity_id) { GCCError error_value; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = REGISTRY_REGISTER_CHANNEL_REQUEST_CHOSEN; error_value = registry_key_data->GetRegistryKeyDataPDU( &gcc_pdu.u.request.u. registry_register_channel_request.key); if (error_value == GCC_NO_ERROR) { gcc_pdu.u.request.u.registry_register_channel_request.channel_id = channel_id; gcc_pdu.u.request.u.registry_register_channel_request.entity_id = entity_id; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { ERROR_OUT(("MCSUser::RegistryRegisterChannelRequest: Error creating packet")); error_value = GCC_ALLOCATION_FAILURE; delete packet; } registry_key_data->FreeRegistryKeyDataPDU(); } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * MCSUser::RegistryAssignTokenRequest() * * Public Function Description: * This routine is used when an APE wishes to register a token in * the application registry. Note that there is no token ID included in * this request. The token ID is allocated at the top provider. */ void MCSUser::RegistryAssignTokenRequest ( CRegKeyContainer *registry_key_data, EntityID entity_id) { GCCError error_value; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = REGISTRY_ASSIGN_TOKEN_REQUEST_CHOSEN; error_value = registry_key_data->GetRegistryKeyDataPDU( &gcc_pdu.u.request.u. registry_assign_token_request.registry_key); if (error_value == GCC_NO_ERROR) { gcc_pdu.u.request.u.registry_assign_token_request.entity_id = entity_id; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; } registry_key_data->FreeRegistryKeyDataPDU(); } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void RegistrySetParameterRequest() * * Public Function Description: * This routine is used when an APE wishes to register a parameter in * the application registry. Note that parameter to be registered is * included in this request. */ void MCSUser::RegistrySetParameterRequest ( CRegKeyContainer *registry_key_data, LPOSTR parameter_value, GCCModificationRights modification_rights, EntityID entity_id) { GCCError error_value; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = REGISTRY_SET_PARAMETER_REQUEST_CHOSEN; gcc_pdu.u.request.u.registry_set_parameter_request.bit_mask = 0; error_value = registry_key_data->GetRegistryKeyDataPDU( &gcc_pdu.u.request.u. registry_set_parameter_request.key); if (error_value == GCC_NO_ERROR) { if (parameter_value != NULL) { gcc_pdu.u.request.u.registry_set_parameter_request. registry_set_parameter.length = parameter_value->length; memcpy (gcc_pdu.u.request.u.registry_set_parameter_request. registry_set_parameter.value, parameter_value->value, parameter_value->length); } else { gcc_pdu.u.request.u.registry_set_parameter_request. registry_set_parameter.length = 0; } gcc_pdu.u.request.u.registry_set_parameter_request.entity_id = entity_id; // Set up the modification rights here if it exists if (modification_rights != GCC_NO_MODIFICATION_RIGHTS_SPECIFIED) { gcc_pdu.u.request.u.registry_set_parameter_request.bit_mask |= PARAMETER_MODIFY_RIGHTS_PRESENT; gcc_pdu.u.request.u.registry_set_parameter_request. parameter_modify_rights = (RegistryModificationRights)modification_rights; } DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; } registry_key_data->FreeRegistryKeyDataPDU(); } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void RegistryRetrieveEntryRequest() * * Public Function Description: * This routine is used when an APE wishes to retrieve an registry item * from the registry. */ void MCSUser::RegistryRetrieveEntryRequest ( CRegKeyContainer *registry_key_data, EntityID entity_id) { GCCError error_value; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = REGISTRY_RETRIEVE_ENTRY_REQUEST_CHOSEN; error_value = registry_key_data->GetRegistryKeyDataPDU( &gcc_pdu.u.request.u. registry_retrieve_entry_request.key); if (error_value == GCC_NO_ERROR) { gcc_pdu.u.request.u.registry_retrieve_entry_request.entity_id = entity_id; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; } registry_key_data->FreeRegistryKeyDataPDU(); } else error_value = GCC_ALLOCATION_FAILURE; if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void RegistryDeleteEntryRequest() * * Public Function Description: * This routine is used when an APE wishes to delete a registry item * from the registry. */ void MCSUser::RegistryDeleteEntryRequest ( CRegKeyContainer *registry_key_data, EntityID entity_id) { GCCError error_value; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = REGISTRY_DELETE_ENTRY_REQUEST_CHOSEN; error_value = registry_key_data->GetRegistryKeyDataPDU( &gcc_pdu.u.request.u. registry_delete_entry_request.key); if (error_value == GCC_NO_ERROR) { gcc_pdu.u.request.u.registry_delete_entry_request.entity_id = entity_id; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; } registry_key_data->FreeRegistryKeyDataPDU(); } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void RegistryMonitorRequest() * * Public Function Description: * This routine is used when an APE wishes to monitor a registry item * in the registry. */ void MCSUser::RegistryMonitorRequest ( CRegKeyContainer *registry_key_data, EntityID entity_id) { GCCError error_value; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = REGISTRY_MONITOR_ENTRY_REQUEST_CHOSEN; error_value = registry_key_data->GetRegistryKeyDataPDU( &gcc_pdu.u.request.u. registry_monitor_entry_request.key); if (error_value == GCC_NO_ERROR) { gcc_pdu.u.request.u.registry_monitor_entry_request.entity_id= entity_id; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; } registry_key_data->FreeRegistryKeyDataPDU(); } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void RegistryAllocateHandleRequest() * * Public Function Description: * This routine is used when an APE wishes to allocate a number of * handles from the application registry. */ void MCSUser::RegistryAllocateHandleRequest( UINT number_of_handles, EntityID entity_id ) { GCCError error_value = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = REGISTRY_ALLOCATE_HANDLE_REQUEST_CHOSEN; gcc_pdu.u.request.u.registry_allocate_handle_request.number_of_handles = (USHORT) number_of_handles; gcc_pdu.u.request.u.registry_allocate_handle_request.entity_id= entity_id; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void RegistryAllocateHandleResponse() * * Public Function Description: * This routine is used by the Top Provider to respond to an allocate * handle request from an APE at a remote node. The allocated handles * are passed back here. */ void MCSUser::RegistryAllocateHandleResponse ( UINT number_of_handles, UINT registry_handle, EntityID requester_entity_id, UserID requester_node_id, GCCResult result) { GCCError error_value = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = REGISTRY_ALLOCATE_HANDLE_RESPONSE_CHOSEN; gcc_pdu.u.response.u.registry_allocate_handle_response.number_of_handles = (USHORT) number_of_handles; gcc_pdu.u.response.u.registry_allocate_handle_response.entity_id = requester_entity_id; gcc_pdu.u.response.u.registry_allocate_handle_response.first_handle = (Handle) registry_handle; if (result == GCC_RESULT_SUCCESSFUL) { gcc_pdu.u.response.u.registry_allocate_handle_response.result = RARS_RESULT_SUCCESS; } else { gcc_pdu.u.response.u.registry_allocate_handle_response.result = NO_HANDLES_AVAILABLE; } DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, requester_node_id, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); error_value = GCC_ALLOCATION_FAILURE; delete packet; } } /* * void RegistryResponse() * * Public Function Description: * This routine is used to respond to all the registry request except * allocate handle. It formulates the response PDU and queues it for * delivery. */ void MCSUser::RegistryResponse ( RegistryResponsePrimitiveType primitive_type, UserID requester_owner_id, EntityID requester_entity_id, CRegKeyContainer *registry_key_data, CRegItem *registry_item_data, GCCModificationRights modification_rights, UserID entry_owner_id, EntityID entry_entity_id, GCCResult result) { GCCError error_value; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; DebugEntry(MCSUser::RegistryResponse); /* ** Encode the conference join response PDU, along with the sequence ** number. */ gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = REGISTRY_RESPONSE_CHOSEN; gcc_pdu.u.response.u.registry_response.bit_mask = 0; error_value = registry_key_data->GetRegistryKeyDataPDU(&gcc_pdu.u.response.u.registry_response.key); if (error_value == GCC_NO_ERROR) { if (registry_item_data != NULL) { registry_item_data->GetRegistryItemDataPDU(&gcc_pdu.u.response.u.registry_response.item); } else { gcc_pdu.u.response.u.registry_response.item.choice = VACANT_CHOSEN; } TRACE_OUT(("MCSUser: RegistryResponse: item_type=%d", (UINT) gcc_pdu.u.response.u.registry_response.item.choice)); // Set up the entry owner if (entry_owner_id != 0) { gcc_pdu.u.response.u.registry_response.owner.choice = OWNED_CHOSEN; gcc_pdu.u.response.u.registry_response.owner.u.owned.node_id = entry_owner_id; gcc_pdu.u.response.u.registry_response.owner.u.owned.entity_id = entry_entity_id; } else { gcc_pdu.u.response.u.registry_response.owner.choice = NOT_OWNED_CHOSEN; } // Set up the requesters entity ID gcc_pdu.u.response.u.registry_response.entity_id = requester_entity_id; // Set up the primitive type gcc_pdu.u.response.u.registry_response.primitive_type = primitive_type; gcc_pdu.u.response.u.registry_response.result = ::TranslateGCCResultToRegistryResp(result); if (modification_rights != GCC_NO_MODIFICATION_RIGHTS_SPECIFIED) { gcc_pdu.u.response.u.registry_response.bit_mask |= RESPONSE_MODIFY_RIGHTS_PRESENT; gcc_pdu.u.response.u.registry_response.response_modify_rights = (RegistryModificationRights)modification_rights; } DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, requester_owner_id, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); error_value = GCC_ALLOCATION_FAILURE; delete packet; } } DebugExitVOID(MCSUser::RegistryResponse); } /* * void RegistryMonitorEntryIndication() * * Public Function Description: * This routine is used by the top provider to issue a monitor * indication anytime a registry entry that is being monitored changes. */ void MCSUser::RegistryMonitorEntryIndication ( CRegKeyContainer *registry_key_data, CRegItem *registry_item_data, UserID entry_owner_id, EntityID entry_entity_id, GCCModificationRights modification_rights) { GCCError error_value; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; /* ** Encode the conference join response PDU, along with the sequence ** number. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = REGISTRY_MONITOR_ENTRY_INDICATION_CHOSEN; gcc_pdu.u.indication.u.registry_monitor_entry_indication.bit_mask = 0; error_value = registry_key_data->GetRegistryKeyDataPDU( &gcc_pdu.u.indication.u. registry_monitor_entry_indication.key); if (error_value == GCC_NO_ERROR) { registry_item_data->GetRegistryItemDataPDU(&gcc_pdu.u.indication.u.registry_monitor_entry_indication.item); // Set up the entry owner if (entry_owner_id != 0) { gcc_pdu.u.indication.u.registry_monitor_entry_indication.owner.choice = OWNED_CHOSEN; gcc_pdu.u.indication.u.registry_monitor_entry_indication.owner.u.owned.node_id = entry_owner_id; gcc_pdu.u.indication.u.registry_monitor_entry_indication.owner.u.owned.entity_id = entry_entity_id; } else { gcc_pdu.u.indication.u.registry_monitor_entry_indication.owner.choice = NOT_OWNED_CHOSEN; } if (modification_rights != GCC_NO_MODIFICATION_RIGHTS_SPECIFIED) { gcc_pdu.u.indication.u.registry_monitor_entry_indication.bit_mask |= RESPONSE_MODIFY_RIGHTS_PRESENT; gcc_pdu.u.indication.u.registry_monitor_entry_indication.entry_modify_rights = (RegistryModificationRights)modification_rights; } DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; } } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /************************************************************************/ /* * GCCError AppInvokeIndication() * * Public Function Description: * This routine is used to send an application invoke indication to * every node in the conference. */ GCCError MCSUser::AppInvokeIndication( CInvokeSpecifierListContainer *invoke_specifier_list, GCCSimpleNodeList *pNodeList) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; PSetOfDestinationNodes new_destination_node; PSetOfDestinationNodes old_destination_node = NULL; PSetOfDestinationNodes pDstNodesToFree = NULL; UINT i; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = APPLICATION_INVOKE_INDICATION_CHOSEN; gcc_pdu.u.indication.u.application_invoke_indication.bit_mask = 0; gcc_pdu.u.indication.u.application_invoke_indication.destination_nodes = NULL; gcc_pdu.u.indication.u.application_invoke_indication.application_protocol_entity_list = NULL; // First, set up the destination node list if (pNodeList->cNodes != 0) { gcc_pdu.u.indication.u.application_invoke_indication.bit_mask |= DESTINATION_NODES_PRESENT; for (i = 0; i < pNodeList->cNodes; i++) { DBG_SAVE_FILE_LINE new_destination_node = new SetOfDestinationNodes; if (new_destination_node != NULL) { if (gcc_pdu.u.indication.u.application_invoke_indication. destination_nodes == NULL) { gcc_pdu.u.indication.u.application_invoke_indication. destination_nodes = new_destination_node; pDstNodesToFree = new_destination_node; } else { old_destination_node->next = new_destination_node; } old_destination_node = new_destination_node; new_destination_node->next = NULL; new_destination_node->value = pNodeList->aNodeIDs[i]; } else { rc = GCC_ALLOCATION_FAILURE; break; } } } if (rc == GCC_NO_ERROR) { rc = invoke_specifier_list->GetApplicationInvokeSpecifierListPDU( &gcc_pdu.u.indication.u.application_invoke_indication. application_protocol_entity_list); } if (rc == GCC_NO_ERROR) { DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } if (NULL != pDstNodesToFree) { PSetOfDestinationNodes p; while (NULL != (p = pDstNodesToFree)) { pDstNodesToFree = pDstNodesToFree->next; delete p; } } if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } return rc; } /* * GCCError TextMessageIndication() * * Public Function Description: * This routine is used to send a text message to either a specific node * or to every node in the conference. */ GCCError MCSUser::TextMessageIndication ( LPWSTR pwszTextMsg, UserID destination_node ) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; LPWSTR pwszMsg; // Encode the PDU that will be forwarded to the top provider. gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = TEXT_MESSAGE_INDICATION_CHOSEN; if (NULL != (pwszMsg = ::My_strdupW(pwszTextMsg))) { gcc_pdu.u.indication.u.text_message_indication.message.length = ::lstrlenW(pwszMsg); gcc_pdu.u.indication.u.text_message_indication.message.value = pwszMsg; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPVOID)&gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue( packet, (destination_node == 0) ? BROADCAST_CHANNEL_ID : destination_node, HIGH_PRIORITY, FALSE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } delete pwszMsg; } else { rc = GCC_ALLOCATION_FAILURE; } if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } return rc; } /* * GCCError ConferenceAssistanceIndication() * * Public Function Description: * This routine is used to send a conference assistance indication to * every node in the conference. */ GCCError MCSUser::ConferenceAssistanceIndication ( UINT number_of_user_data_members, PGCCUserData * user_data_list) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; CUserDataListContainer *user_data_record; DebugEntry(MCSUser::ConferenceAssistanceIndication); // Encode the PDU gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_ASSISTANCE_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_assistance_indication.bit_mask = 0; // Construct the user data list container if ((number_of_user_data_members != 0) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE user_data_record = new CUserDataListContainer(number_of_user_data_members, user_data_list, &rc); if (user_data_record == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { user_data_record = NULL; } if ((user_data_record != NULL) && (rc == GCC_NO_ERROR)) { rc = user_data_record->GetUserDataPDU( &gcc_pdu.u.indication.u.conference_assistance_indication. cain_user_data); gcc_pdu.u.indication.u.conference_assistance_indication.bit_mask |= CAIN_USER_DATA_PRESENT; } if (rc == GCC_NO_ERROR) { DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } // Clean up containers if (user_data_record != NULL) { user_data_record->Release(); } return (rc); } /* * GCCError ConferenceTransferRequest() * * Public Function Description: * This routine is used to send a conference transfer request to the * top provider in the conference. */ GCCError MCSUser::ConferenceTransferRequest ( PGCCConferenceName destination_conference_name, GCCNumericString destination_conference_modifier, CNetAddrListContainer *destination_address_list, UINT number_of_destination_nodes, PUserID destination_node_list, CPassword *password) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; UINT string_length; PSetOfTransferringNodesRq new_set_of_nodes; PSetOfTransferringNodesRq old_set_of_nodes; UINT i; DebugEntry(MCSUser::ConferenceTransferRequest); // Encode the PDU gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = CONFERENCE_TRANSFER_REQUEST_CHOSEN; gcc_pdu.u.request.u.conference_transfer_request.bit_mask = 0; // First get the conference name (either numeric or text). if (destination_conference_name->numeric_string != NULL) { gcc_pdu.u.request.u.conference_transfer_request.conference_name.choice = NAME_SELECTOR_NUMERIC_CHOSEN; lstrcpy (gcc_pdu.u.request.u.conference_transfer_request. conference_name.u.name_selector_numeric, (LPSTR)destination_conference_name->numeric_string); } else { // Use a unicode string to determine the length gcc_pdu.u.request.u.conference_transfer_request.conference_name.choice = NAME_SELECTOR_TEXT_CHOSEN; string_length = ::My_strlenW(destination_conference_name->text_string); gcc_pdu.u.request.u.conference_transfer_request. conference_name.u.name_selector_text.length = string_length; gcc_pdu.u.request.u.conference_transfer_request. conference_name.u.name_selector_text.value = destination_conference_name->text_string; } // Next get the conference name modifier if it exists if (destination_conference_modifier != NULL) { gcc_pdu.u.request.u.conference_transfer_request.bit_mask |= CTRQ_CONFERENCE_MODIFIER_PRESENT; lstrcpy (gcc_pdu.u.request.u.conference_transfer_request. ctrq_conference_modifier, (LPSTR)destination_conference_modifier); } // Get the network address list if it exist if (destination_address_list != NULL) { gcc_pdu.u.request.u.conference_transfer_request.bit_mask |= CTRQ_NETWORK_ADDRESS_PRESENT; rc = destination_address_list->GetNetworkAddressListPDU ( &gcc_pdu.u.request.u.conference_transfer_request. ctrq_net_address); } // Get the destination node list if it exists if ((number_of_destination_nodes != 0) && (rc == GCC_NO_ERROR)) { gcc_pdu.u.request.u.conference_transfer_request.bit_mask |= CTRQ_TRANSFERRING_NODES_PRESENT; old_set_of_nodes = NULL; gcc_pdu.u.request.u.conference_transfer_request. ctrq_transferring_nodes = NULL; for (i = 0; i < number_of_destination_nodes; i++) { DBG_SAVE_FILE_LINE new_set_of_nodes = new SetOfTransferringNodesRq; if (new_set_of_nodes == NULL) { rc = GCC_ALLOCATION_FAILURE; break; } else new_set_of_nodes->next = NULL; if (old_set_of_nodes == NULL) { gcc_pdu.u.request.u.conference_transfer_request. ctrq_transferring_nodes = new_set_of_nodes; } else old_set_of_nodes->next = new_set_of_nodes; old_set_of_nodes = new_set_of_nodes; new_set_of_nodes->value = destination_node_list[i]; } } // Get the password if it exists if ((password != NULL) && (rc == GCC_NO_ERROR)) { gcc_pdu.u.request.u.conference_transfer_request.bit_mask |= CTRQ_PASSWORD_PRESENT; rc = password->GetPasswordSelectorPDU ( &gcc_pdu.u.request.u.conference_transfer_request.ctrq_password); } // Encode the PDU if (rc == GCC_NO_ERROR) { DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } // Clean up the node list if it was created if (gcc_pdu.u.request.u.conference_transfer_request.bit_mask & CTRQ_TRANSFERRING_NODES_PRESENT) { old_set_of_nodes = gcc_pdu.u.request.u.conference_transfer_request. ctrq_transferring_nodes; while (old_set_of_nodes != NULL) { new_set_of_nodes = old_set_of_nodes->next; delete old_set_of_nodes; old_set_of_nodes = new_set_of_nodes; } } return rc; } /* * GCCError ConferenceTransferIndication() * * Public Function Description: * This routine is used by the top provider to send out the transfer * indication to every node in the conference. It is each nodes * responsiblity to search the destination node list to see if * it should transfer. */ GCCError MCSUser::ConferenceTransferIndication ( PGCCConferenceName destination_conference_name, GCCNumericString destination_conference_modifier, CNetAddrListContainer *destination_address_list, UINT number_of_destination_nodes, PUserID destination_node_list, CPassword *password) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; UINT string_length; PSetOfTransferringNodesIn new_set_of_nodes; PSetOfTransferringNodesIn old_set_of_nodes; UINT i; DebugEntry(MCSUser::ConferenceTransferIndication); // Encode the PDU gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_TRANSFER_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_transfer_indication.bit_mask = 0; // First get the conference name (either numeric or text). if (destination_conference_name->numeric_string != NULL) { gcc_pdu.u.indication.u.conference_transfer_indication. conference_name.choice = NAME_SELECTOR_NUMERIC_CHOSEN; lstrcpy (gcc_pdu.u.indication.u.conference_transfer_indication. conference_name.u.name_selector_numeric, (LPSTR)destination_conference_name->numeric_string); } else { // Use a unicode string to determine the length gcc_pdu.u.indication.u.conference_transfer_indication. conference_name.choice = NAME_SELECTOR_TEXT_CHOSEN; string_length = ::My_strlenW(destination_conference_name->text_string); gcc_pdu.u.indication.u.conference_transfer_indication. conference_name.u.name_selector_text.length = string_length; gcc_pdu.u.indication.u.conference_transfer_indication. conference_name.u.name_selector_text.value = destination_conference_name->text_string; } // Next get the conference name modifier if it exists if (destination_conference_modifier != NULL) { gcc_pdu.u.indication.u.conference_transfer_indication.bit_mask |= CTIN_CONFERENCE_MODIFIER_PRESENT; lstrcpy (gcc_pdu.u.indication.u.conference_transfer_indication. ctin_conference_modifier, (LPSTR)destination_conference_modifier); } // Get the network address list if it exist if (destination_address_list != NULL) { gcc_pdu.u.indication.u.conference_transfer_indication.bit_mask |= CTIN_NETWORK_ADDRESS_PRESENT; rc = destination_address_list->GetNetworkAddressListPDU ( &gcc_pdu.u.indication.u.conference_transfer_indication. ctin_net_address); } // Get the destination node list if it exists if ((number_of_destination_nodes != 0) && (rc == GCC_NO_ERROR)) { gcc_pdu.u.indication.u.conference_transfer_indication.bit_mask |= CTIN_TRANSFERRING_NODES_PRESENT; old_set_of_nodes = NULL; gcc_pdu.u.indication.u.conference_transfer_indication. ctin_transferring_nodes = NULL; for (i = 0; i < number_of_destination_nodes; i++) { DBG_SAVE_FILE_LINE new_set_of_nodes = new SetOfTransferringNodesIn; if (new_set_of_nodes == NULL) { rc = GCC_ALLOCATION_FAILURE; break; } else new_set_of_nodes->next = NULL; if (old_set_of_nodes == NULL) { gcc_pdu.u.indication.u.conference_transfer_indication. ctin_transferring_nodes = new_set_of_nodes; } else old_set_of_nodes->next = new_set_of_nodes; old_set_of_nodes = new_set_of_nodes; new_set_of_nodes->value = destination_node_list[i]; } } // Get the password if it exists if ((password != NULL) && (rc == GCC_NO_ERROR)) { gcc_pdu.u.indication.u.conference_transfer_indication.bit_mask |= CTIN_PASSWORD_PRESENT; rc = password->GetPasswordSelectorPDU ( &gcc_pdu.u.indication.u.conference_transfer_indication. ctin_password); } // Encode the PDU if (rc == GCC_NO_ERROR) { DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } // Clean up the node list if it was created if (gcc_pdu.u.indication.u.conference_transfer_indication.bit_mask & CTIN_TRANSFERRING_NODES_PRESENT) { old_set_of_nodes = gcc_pdu.u.indication.u. conference_transfer_indication.ctin_transferring_nodes; while (old_set_of_nodes != NULL) { new_set_of_nodes = old_set_of_nodes->next; delete old_set_of_nodes; old_set_of_nodes = new_set_of_nodes; } } DebugExitINT(MCSUser::ConferenceTransferIndication, rc); return rc; } /* * GCCError ConferenceTransferResponse() * * Public Function Description: * This routine is used by the top provider to send back a response to * the node that made a transfer request. The info specified in the * request is included in the response to match request to response. */ GCCError MCSUser::ConferenceTransferResponse ( UserID requesting_node_id, PGCCConferenceName destination_conference_name, GCCNumericString destination_conference_modifier, UINT number_of_destination_nodes, PUserID destination_node_list, GCCResult result) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; UINT string_length; PSetOfTransferringNodesRs new_set_of_nodes; PSetOfTransferringNodesRs old_set_of_nodes; UINT i; DebugEntry(MCSUser::ConferenceTransferResponse); // Encode the PDU gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = CONFERENCE_TRANSFER_RESPONSE_CHOSEN; gcc_pdu.u.response.u.conference_transfer_response.bit_mask = 0; // First get the conference name (either numeric or text). if (destination_conference_name->numeric_string != NULL) { gcc_pdu.u.response.u.conference_transfer_response. conference_name.choice = NAME_SELECTOR_NUMERIC_CHOSEN; ::lstrcpyA(gcc_pdu.u.response.u.conference_transfer_response. conference_name.u.name_selector_numeric, (LPSTR)destination_conference_name->numeric_string); } else { // Use a unicode string to determine the length gcc_pdu.u.response.u.conference_transfer_response. conference_name.choice = NAME_SELECTOR_TEXT_CHOSEN; string_length = ::My_strlenW(destination_conference_name->text_string); gcc_pdu.u.response.u.conference_transfer_response. conference_name.u.name_selector_text.length = string_length; gcc_pdu.u.response.u.conference_transfer_response. conference_name.u.name_selector_text.value = destination_conference_name->text_string; } // Next get the conference name modifier if it exists if (destination_conference_modifier != NULL) { gcc_pdu.u.response.u.conference_transfer_response.bit_mask |= CTRS_CONFERENCE_MODIFIER_PRESENT; ::lstrcpyA(gcc_pdu.u.response.u.conference_transfer_response. ctrs_conference_modifier, (LPSTR)destination_conference_modifier); } // Get the destination node list if it exists if ((number_of_destination_nodes != 0) && (rc == GCC_NO_ERROR)) { gcc_pdu.u.response.u.conference_transfer_response.bit_mask |= CTRS_TRANSFERRING_NODES_PRESENT; old_set_of_nodes = NULL; gcc_pdu.u.response.u.conference_transfer_response. ctrs_transferring_nodes = NULL; for (i = 0; i < number_of_destination_nodes; i++) { DBG_SAVE_FILE_LINE new_set_of_nodes = new SetOfTransferringNodesRs; if (new_set_of_nodes == NULL) { rc = GCC_ALLOCATION_FAILURE; break; } else new_set_of_nodes->next = NULL; if (old_set_of_nodes == NULL) { gcc_pdu.u.response.u.conference_transfer_response. ctrs_transferring_nodes = new_set_of_nodes; } else old_set_of_nodes->next = new_set_of_nodes; old_set_of_nodes = new_set_of_nodes; new_set_of_nodes->value = destination_node_list[i]; } } // Set up the result if (result == GCC_RESULT_SUCCESSFUL) { gcc_pdu.u.response.u.conference_transfer_response.result = CTRANS_RESULT_SUCCESS; } else { gcc_pdu.u.response.u.conference_transfer_response.result = CTRANS_RESULT_INVALID_REQUESTER; } // Encode the PDU if (rc == GCC_NO_ERROR) { DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, requesting_node_id, HIGH_PRIORITY, FALSE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } // Clean up the node list if it was created if (gcc_pdu.u.response.u.conference_transfer_response.bit_mask & CTRS_TRANSFERRING_NODES_PRESENT) { old_set_of_nodes = gcc_pdu.u.response.u. conference_transfer_response.ctrs_transferring_nodes; while (old_set_of_nodes != NULL) { new_set_of_nodes = old_set_of_nodes->next; delete old_set_of_nodes; old_set_of_nodes = new_set_of_nodes; } } DebugExitINT(MCSUser::ConferenceTransferResponse, rc); return rc; } /* * GCCError ConferenceAddRequest() * * Public Function Description: * This routine is used to send a conference add request to the appropriate * node. This call can be made by the requesting node or by the top * provider to pass the add request on to the adding node. */ GCCError MCSUser::ConferenceAddRequest ( TagNumber conference_add_tag, UserID requesting_node, UserID adding_node, UserID target_node, CNetAddrListContainer *network_address_container, CUserDataListContainer *user_data_container) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; DebugEntry(MCSUser::ConferenceAddRequest); // Encode the PDU gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = CONFERENCE_ADD_REQUEST_CHOSEN; gcc_pdu.u.request.u.conference_add_request.bit_mask = 0; // Get the network address list if it exist if (network_address_container != NULL) { // Set up the network address portion of the pdu rc = network_address_container->GetNetworkAddressListPDU ( &gcc_pdu.u.request.u.conference_add_request. add_request_net_address); // Set up the user data container if ((rc == GCC_NO_ERROR) && (user_data_container != NULL)) { rc = user_data_container->GetUserDataPDU ( &gcc_pdu.u.request.u.conference_add_request.carq_user_data); if (rc == GCC_NO_ERROR) { gcc_pdu.u.request.u.conference_add_request.bit_mask |= CARQ_USER_DATA_PRESENT; } } // Encode the PDU if (rc == GCC_NO_ERROR) { // specify the requesting node gcc_pdu.u.request.u.conference_add_request.requesting_node = requesting_node; if (adding_node != 0) { gcc_pdu.u.request.u.conference_add_request.bit_mask |= ADDING_MCU_PRESENT; gcc_pdu.u.request.u.conference_add_request.adding_mcu = adding_node; } gcc_pdu.u.request.u.conference_add_request.tag = conference_add_tag; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, target_node, HIGH_PRIORITY, FALSE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } } else { rc = GCC_BAD_NETWORK_ADDRESS; } DebugExitINT(MCSUser::ConferenceAddRequest, rc); return rc; } /* * GCCError ConferenceAddResponse() * * Public Function Description: * This routine is used to send a conference add request to the appropriate * node. This call can be made by the requesting node or by the top * provider to pass the add request on to the adding node. */ GCCError MCSUser::ConferenceAddResponse( TagNumber add_request_tag, UserID requesting_node, CUserDataListContainer *user_data_container, GCCResult result) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; DebugEntry(MCSUser::ConferenceAddResponse); // Encode the PDU gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = CONFERENCE_ADD_RESPONSE_CHOSEN; gcc_pdu.u.response.u.conference_add_response.bit_mask = 0; // Set up the user data container if ((rc == GCC_NO_ERROR) && (user_data_container != NULL)) { rc = user_data_container->GetUserDataPDU ( &gcc_pdu.u.response.u.conference_add_response.cars_user_data); if (rc == GCC_NO_ERROR) { gcc_pdu.u.response.u.conference_add_response.bit_mask |= CARS_USER_DATA_PRESENT; } } // Encode the PDU if (rc == GCC_NO_ERROR) { gcc_pdu.u.response.u.conference_add_response.tag = add_request_tag; gcc_pdu.u.response.u.conference_add_response.result = ::TranslateGCCResultToAddResult(result); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, requesting_node, HIGH_PRIORITY, FALSE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } DebugExitINT(MCSUser::ConferenceAddResponse, rc); return rc; } /************************* Conductorship Calls ***********************/ /* * GCCError ConductorTokenGrab() * * Public Function Description: * This routine makes the MCS calls to grab the conductor token. */ GCCError MCSUser::ConductorTokenGrab() { MCSError mcs_error; mcs_error = g_pMCSIntf->TokenGrabRequest(m_pMCSSap, CONDUCTOR_TOKEN_ID); return (g_pMCSIntf->TranslateMCSIFErrorToGCCError (mcs_error)); } /* * GCCError ConductorTokenRelease() * * Public Function Description: * This routine makes the MCS calls to release the conductor token. */ GCCError MCSUser::ConductorTokenRelease() { MCSError mcs_error; mcs_error = g_pMCSIntf->TokenReleaseRequest(m_pMCSSap, CONDUCTOR_TOKEN_ID); return (g_pMCSIntf->TranslateMCSIFErrorToGCCError (mcs_error)); } /* * GCCError ConductorTokenPlease() * * Public Function Description: * This routine makes the MCS calls to request the conductor token from * the current conductor. */ GCCError MCSUser::ConductorTokenPlease() { MCSError mcs_error; mcs_error = g_pMCSIntf->TokenPleaseRequest(m_pMCSSap, CONDUCTOR_TOKEN_ID); return (g_pMCSIntf->TranslateMCSIFErrorToGCCError (mcs_error)); } /* * GCCError ConductorTokenGive () * * Public Function Description: * This routine makes the MCS calls to give the conductor token to the * specified node. */ GCCError MCSUser::ConductorTokenGive(UserID recipient_user_id) { MCSError mcs_error; mcs_error = g_pMCSIntf->TokenGiveRequest(m_pMCSSap, CONDUCTOR_TOKEN_ID, recipient_user_id); return (g_pMCSIntf->TranslateMCSIFErrorToGCCError (mcs_error)); } /* * GCCError ConductorTokenGiveResponse () * * Public Function Description: * This routine makes the MCS calls to respond to a conductor give * request. */ GCCError MCSUser::ConductorTokenGiveResponse(Result result) { MCSError mcs_error; mcs_error = g_pMCSIntf->TokenGiveResponse(m_pMCSSap, CONDUCTOR_TOKEN_ID, result); return g_pMCSIntf->TranslateMCSIFErrorToGCCError(mcs_error); } /* * GCCError ConductorTokenTest () * * Public Function Description: * This routine is used to test the current state of the conductor token * (is it grabbed or not). */ GCCError MCSUser::ConductorTokenTest() { MCSError mcs_error; mcs_error = g_pMCSIntf->TokenTestRequest(m_pMCSSap, CONDUCTOR_TOKEN_ID); return g_pMCSIntf->TranslateMCSIFErrorToGCCError(mcs_error); } /* * GCCError SendConductorAssignIndication() * * Public Function Description: * This routine sends a conductor assign indication to all the * nodes in the conference. */ GCCError MCSUser::SendConductorAssignIndication( UserID conductor_user_id) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; /* ** Fill in the ConductorAssignIndication pdu structure to be passed in the ** constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONDUCTOR_ASSIGN_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conductor_assign_indication.user_id = conductor_user_id; /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, TOP_PRIORITY, TRUE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConductorReleaseIndication() * * Public Function Description: * This routine sends a conductor release indication to all the * nodes in the conference. */ GCCError MCSUser::SendConductorReleaseIndication() { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; /* ** Fill in the ConductorAssignIndication pdu structure to be passed in the ** constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONDUCTOR_RELEASE_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conductor_release_indication.placeholder = 0; /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, TOP_PRIORITY, TRUE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConductorPermitAsk () * * Public Function Description: * This routine sends a conductor permission ask request directly to the * conductor node. */ GCCError MCSUser::SendConductorPermitAsk ( BOOL grant_permission) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; /* ** Fill in the ConductorPermissionAskIndication pdu structure to be passed ** in the constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONDUCTOR_PERMISSION_ASK_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conductor_permission_ask_indication. permission_is_granted = (ASN1bool_t)grant_permission; /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError SendConductorPermitGrant () * * Public Function Description: * This routine sends a conductor permission grant indication to every * node in the conference. Usually issued when permissions change. */ GCCError MCSUser::SendConductorPermitGrant ( UINT number_granted, PUserID granted_node_list, UINT number_waiting, PUserID waiting_node_list) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; PPermissionList permission_list; PPermissionList previous_permission_list; PWaitingList waiting_list; PWaitingList previous_waiting_list; UINT i; /* ** Fill in the ConductorPermissionAskIndication pdu structure to be passed ** in the constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONDUCTOR_PERMISSION_GRANT_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conductor_permission_grant_indication.bit_mask = 0; // First fill in the granted node permission list gcc_pdu.u.indication.u. conductor_permission_grant_indication.permission_list = NULL; previous_permission_list = NULL; for (i = 0; i < number_granted; i++) { DBG_SAVE_FILE_LINE permission_list = new PermissionList; if (permission_list == NULL) { rc = GCC_ALLOCATION_FAILURE; break; } if (previous_permission_list == NULL) { gcc_pdu.u.indication.u.conductor_permission_grant_indication. permission_list = permission_list; } else previous_permission_list->next = permission_list; previous_permission_list = permission_list; permission_list->value = granted_node_list[i]; permission_list->next = NULL; } // If waiting list exists fill it in if ((number_waiting != 0) && (rc == GCC_NO_ERROR)) { gcc_pdu.u.indication.u.conductor_permission_grant_indication.bit_mask = WAITING_LIST_PRESENT; gcc_pdu.u.indication.u. conductor_permission_grant_indication.waiting_list = NULL; previous_waiting_list = NULL; for (i = 0; i < number_waiting; i++) { DBG_SAVE_FILE_LINE waiting_list = new WaitingList; if (waiting_list == NULL) { rc = GCC_ALLOCATION_FAILURE; break; } if (previous_waiting_list == NULL) { gcc_pdu.u.indication.u.conductor_permission_grant_indication. waiting_list = waiting_list; } else previous_waiting_list->next = waiting_list; previous_waiting_list = waiting_list; waiting_list->value = waiting_node_list[i]; waiting_list->next = NULL; } } /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, TOP_PRIORITY, TRUE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /**********************************************************************/ /***************** Miscelaneous calls ******************************/ /* * GCCError TimeRemainingRequest() * * Public Function Description: * This routine sends out an indication to every node in the * conference informing how much time is remaining in the conference. */ GCCError MCSUser::TimeRemainingRequest ( UINT time_remaining, UserID node_id) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; /* ** Fill in the TimeRemainingRequest pdu structure to be passed in the ** constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_TIME_REMAINING_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_time_remaining_indication.bit_mask = 0; gcc_pdu.u.indication.u.conference_time_remaining_indication.time_remaining = time_remaining; if (node_id != 0) { gcc_pdu.u.indication.u.conference_time_remaining_indication.bit_mask |= TIME_REMAINING_NODE_ID_PRESENT; gcc_pdu.u.indication.u.conference_time_remaining_indication. time_remaining_node_id = node_id; } /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError TimeInquireRequest() * * Public Function Description: * This routine sends out a request for a time remaing update. */ GCCError MCSUser::TimeInquireRequest ( BOOL time_is_conference_wide) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; /* ** Fill in the TimeInquireRequest pdu structure to be passed in the ** constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_TIME_INQUIRE_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_time_inquire_indication. time_is_node_specific = (ASN1bool_t)time_is_conference_wide; /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, CONVENER_CHANNEL_ID, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * GCCError ConferenceExtendIndication() * * Public Function Description: * This routine sends out an indication informing conference participants * of an extension. */ GCCError MCSUser::ConferenceExtendIndication ( UINT extension_time, BOOL time_is_conference_wide) { GCCError rc = GCC_NO_ERROR; PPacket packet; GCCPDU gcc_pdu; PacketError packet_error; /* ** Fill in the ConfernceExtendIndication pdu structure to be passed in the ** constructor of the packet class. */ gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_TIME_EXTEND_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_time_extend_indication. time_to_extend = extension_time; gcc_pdu.u.indication.u.conference_time_extend_indication. time_is_node_specific = (ASN1bool_t)time_is_conference_wide; /* ** Create a packet object */ DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, // pdu_type TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, CONVENER_CHANNEL_ID, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * void ConferenceJoinResponse() * * Functional Description: * This function is called by the conference object of the * top provider when it wants to send the join response back to the gcc * provider that made the join request, through the directly connected * intermediate node. This function does the encoding of the join response * PDU and also adds the sequence number sent in the request. */ void MCSUser::ConferenceJoinResponse( UserID receiver_id, BOOL password_is_in_the_clear, BOOL conference_locked, BOOL conference_listed, GCCTerminationMethod termination_method, CPassword *password_challenge, CUserDataListContainer *user_data_list, GCCResult result) { GCCError rc = GCC_NO_ERROR; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; TagNumber lTagNum; if (0 == (lTagNum = m_ConfJoinResponseList2.Find(receiver_id))) { WARNING_OUT(("MCSUser::ConferenceJoinResponse: Unexpected Join Response")); return; } /* ** Encode the conference join response PDU, along with the sequence ** number. */ gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = CONFERENCE_JOIN_RESPONSE_CHOSEN; gcc_pdu.u.response.u.conference_join_response.bit_mask = 0; /* ** Get the sequence number of the outstanding response from the ** list of seq # vs userID using the userID passed from above. */ gcc_pdu.u.response.u.conference_join_response.tag = lTagNum; // Remove this entry from the list. m_ConfJoinResponseList2.Remove(receiver_id); // Get password challenge PDU if ((password_challenge != NULL) && (rc == GCC_NO_ERROR)) { rc = password_challenge->GetPasswordChallengeResponsePDU ( &gcc_pdu.u.response.u.conference_join_response.cjrs_password); if (rc == GCC_NO_ERROR) { gcc_pdu.u.response.u.conference_join_response.bit_mask |= CJRS_PASSWORD_PRESENT; } } // Get user data list PDU if ((user_data_list != NULL) && (rc == GCC_NO_ERROR)) { rc = user_data_list->GetUserDataPDU ( &gcc_pdu.u.response.u.conference_join_response.cjrs_user_data); if (rc == GCC_NO_ERROR) { gcc_pdu.u.response.u.conference_join_response.bit_mask |= CJRS_USER_DATA_PRESENT; } } if (rc == GCC_NO_ERROR) { gcc_pdu.u.response.u.conference_join_response. top_node_id = m_nidTopProvider; gcc_pdu.u.response.u.conference_join_response. clear_password_required = (ASN1bool_t)password_is_in_the_clear; gcc_pdu.u.response.u.conference_join_response. conference_is_locked = (ASN1bool_t)conference_locked; gcc_pdu.u.response.u.conference_join_response. conference_is_listed = (ASN1bool_t)conference_listed; gcc_pdu.u.response.u.conference_join_response.termination_method = (TerminationMethod)termination_method; gcc_pdu.u.response.u.conference_join_response.result = ::TranslateGCCResultToJoinResult(result); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, receiver_id, TOP_PRIORITY, FALSE); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void ConferenceTerminateRequest() * * Functional Description: * This routine is used by a node subordinate to the top provider to * request that the conference by terminated. */ void MCSUser::ConferenceTerminateRequest( GCCReason reason) { GCCError error_value = GCC_NO_ERROR; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = CONFERENCE_TERMINATE_REQUEST_CHOSEN; gcc_pdu.u.request.u.conference_terminate_request.reason = ::TranslateGCCReasonToTerminateRqReason(reason); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, m_nidTopProvider, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); error_value = GCC_ALLOCATION_FAILURE; delete packet; } } /* * void ConferenceTerminateResponse () * * Functional Description: * This routine is used by the top provider to respond to a terminate * request issued by a subordinate node. The result indicates if the * requesting node had the correct privileges. */ void MCSUser::ConferenceTerminateResponse ( UserID requester_id, GCCResult result) { GCCError error_value = GCC_NO_ERROR; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = CONFERENCE_TERMINATE_RESPONSE_CHOSEN; gcc_pdu.u.response.u.conference_terminate_response.result = ::TranslateGCCResultToTerminateResult(result); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, requester_id, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); error_value = GCC_ALLOCATION_FAILURE; delete packet; } } /* * GCCError ConferenceTerminateIndication() * * Functional Description: * This routine is used by the top provider to send out a terminate * indication to every node in the conference. */ void MCSUser::ConferenceTerminateIndication ( GCCReason reason) { GCCError error_value = GCC_NO_ERROR; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_TERMINATE_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_terminate_indication.reason = ::TranslateGCCReasonToTerminateInReason(reason); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } else { ResourceFailureHandler(); error_value = GCC_ALLOCATION_FAILURE; delete packet; } } /* * void EjectNodeFromConference() * * Functional Description: * This routine is used when attempting to eject a node from the * conference. */ GCCError MCSUser::EjectNodeFromConference ( UserID ejected_node_id, GCCReason reason) { GCCError rc = GCC_NO_ERROR; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; ChannelID channel_id; BOOL uniform_send; Priority priority; PAlarm alarm; if (ejected_node_id == m_nidMyself) { /* ** If the ejected node is this node we can immediately initiate the ** ejection. There is no need to request this through the Top ** Provider. */ rc = InitiateEjectionFromConference (reason); } else { /* ** If the ejected node is a child node to this node we can directly ** eject it. Otherwise the request is forwarded to the Top Provider. */ if (m_ChildUidConnHdlList2.Find(ejected_node_id) || (m_nidTopProvider == m_nidMyself)) { gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_EJECT_USER_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_eject_user_indication. node_to_eject = ejected_node_id; gcc_pdu.u.indication.u.conference_eject_user_indication.reason = ::TranslateGCCReasonToEjectInd(reason); uniform_send = TRUE; channel_id = BROADCAST_CHANNEL_ID; // If this is the top provider send the data at TOP priority if (m_nidTopProvider == m_nidMyself) priority = TOP_PRIORITY; else priority = HIGH_PRIORITY; /* ** Set up ejection alarm to automatically eject any misbehaving ** nodes. Note that we only do this if we are directly connected ** to the node to be ejected. */ if (m_ChildUidConnHdlList2.Find(ejected_node_id)) { DBG_SAVE_FILE_LINE alarm = new Alarm (EJECTED_NODE_TIMER_DURATION); if (alarm != NULL) { /* ** Here we save the alarm in a list of ejected nodes. This ** alarm is used to cleanup any misbehaving node. */ m_EjectedNodeAlarmList2.Append(ejected_node_id, alarm); } else { rc = GCC_ALLOCATION_FAILURE; } } } else { gcc_pdu.choice = REQUEST_CHOSEN; gcc_pdu.u.request.choice = CONFERENCE_EJECT_USER_REQUEST_CHOSEN; gcc_pdu.u.request.u.conference_eject_user_request.node_to_eject = ejected_node_id; // The only valid reason is user initiated which is zero gcc_pdu.u.request.u.conference_eject_user_request.reason = CERQ_REASON_USER_INITIATED; uniform_send = FALSE; channel_id = m_nidTopProvider; priority = TOP_PRIORITY; } if (rc == GCC_NO_ERROR) { DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, channel_id, priority, uniform_send); } else { rc = GCC_ALLOCATION_FAILURE; delete packet; } } } if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } return rc; } /* * void SendEjectNodeResponse() * * Functional Description: * This routine is used by the top provider to respond to an eject * user request. */ GCCError MCSUser::SendEjectNodeResponse ( UserID requester_id, UserID node_to_eject, GCCResult result) { GCCError rc = GCC_NO_ERROR; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; gcc_pdu.choice = RESPONSE_CHOSEN; gcc_pdu.u.response.choice = CONFERENCE_EJECT_USER_RESPONSE_CHOSEN; gcc_pdu.u.response.u.conference_eject_user_response.node_to_eject = node_to_eject; gcc_pdu.u.response.u.conference_eject_user_response.result = ::TranslateGCCResultToEjectResult(result); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, requester_id, HIGH_PRIORITY, FALSE); } else { ResourceFailureHandler(); rc = GCC_ALLOCATION_FAILURE; delete packet; } return rc; } /* * void RosterUpdateIndication() * * Functional Description: * This routine is used to forward a roster update indication either * upward to the parent node or downward as a full refresh to all nodes * in the conference. */ void MCSUser::RosterUpdateIndication(PGCCPDU gcc_pdu, BOOL send_update_upward) { PPacket packet; PacketError packet_error; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { if (send_update_upward) { AddToMCSMessageQueue(packet, m_nidParent, HIGH_PRIORITY, FALSE); } else { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); } } else { ResourceFailureHandler(); delete packet; } } /* * void AddToMCSMessageQueue() * * Private Function Description: * This function adds the out bound messages to a queue which is * flushed in the next heartbeat when controller call FlushMessageQueue. * In case memory allocation for messages holding the out bound inform- * ation fails an owner call back is sent to conference object to * indicate insufficient memory. * * Formal Parameters: * packet - (i) Pointer to packet to queue up. * send_data_request_info - (i) Structure containing all the info * necessary to deliver the packet. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: AddToMCSMessageQueue ( PPacket packet, ChannelID channel_id, Priority priority, BOOL uniform_send ) { SEND_DATA_REQ_INFO *pReqInfo; DBG_SAVE_FILE_LINE pReqInfo = new SEND_DATA_REQ_INFO; if (pReqInfo != NULL) { pReqInfo->packet = packet; pReqInfo->channel_id = channel_id; pReqInfo->priority = priority; pReqInfo->uniform_send = uniform_send; /* ** This forces the packet to be encoded. This must happen here so ** that any memory used by the decoded portion of the packet can ** be freed after returning. */ // packet->Lock(); m_OutgoingPDUQueue.Append(pReqInfo); if (m_OutgoingPDUQueue.GetCount() == 1) { if (FlushOutgoingPDU()) { // Inform the MCS interface that there are PDUs queued g_pGCCController->SetEventToFlushOutgoingPDU(); } } else { // Inform the MCS interface that there are PDUs queued g_pGCCController->SetEventToFlushOutgoingPDU(); } } else { ResourceFailureHandler(); /* ** This just sets a flag in the packet object that allows packet ** to commit suicide if lock count on encoded and decoded data is ** zero. This will occur once the packet is sent on to MCS. */ packet->Unlock(); } } /* * BOOL FlushOutgoingPDU() * * Public Function Description: * This function is called by the owner object in every heartbeat. This * function iterates throught the list of pending out bound messages * and sends them down to MCS. Also after a successful send it frees * any resources tied up with the outbound messages. If however a message * can not be sent in this heartbeat, as indicated by MCS, then it * inserts the message back onto the message queue and returns. * * Return value: * TRUE, if there remain un-processed msgs in the MCS message queue * FALSE, if all the msgs in the MCS msg queue were processed. */ void MCSUser:: CheckEjectedNodeAlarms ( void ) { /* ** We first check the eject user list to make sure that no alarms have ** expired on any of the ejected nodes. */ if (m_EjectedNodeAlarmList2.IsEmpty() == FALSE) { PAlarm lpAlarm; UserID uid; // We copy the list so that we can remove entries in the iterator while (NULL != (lpAlarm = m_EjectedNodeAlarmList2.Get(&uid))) { // Has the alarm expired for this node? if (lpAlarm->IsExpired()) { ConnectionHandle hConn; /* ** Tell the owner object to disconnect the misbehaving node ** that exists at the connection handle accessed through ** the m_ChildUidConnHdlList2. */ if (NULL != (hConn = m_ChildUidConnHdlList2.Find(uid))) { // // This must generate a disconnect provider for eject node to // work properly. // g_pMCSIntf->DisconnectProviderRequest(hConn); // // Since this node will not get a disconnect indication when it // issues a DisconnectProviderRequest we go ahead and call it // from here. // m_pConf->DisconnectProviderIndication(hConn); } } // Delete the alarm delete lpAlarm; } } } BOOL MCSUser:: FlushOutgoingPDU ( void ) { DWORD mcs_message_count; DWORD count; UINT rc; SEND_DATA_REQ_INFO *pReqInfo; mcs_message_count = m_OutgoingPDUQueue.GetCount(); for (count = 0; (count < mcs_message_count) && (m_OutgoingPDUQueue.IsEmpty() == FALSE); count++) { /* ** Get the next message from the queue. */ pReqInfo = m_OutgoingPDUQueue.Get(); /* * If MCS takes the request without an error, free information * structure and unlock the encoded information in the packet. * Unlocking the packet before deleting the infomration structure * ensures that packet object is deleted and not left dangling. * This is true because here only one lock is performed. * If there is an error in the send data request, it means mcs can not * take any more requests, therefore insert the information * structure back in the queue and break out of this loop. */ if (pReqInfo->uniform_send) { rc = g_pMCSIntf->UniformSendDataRequest( pReqInfo->channel_id, m_pMCSSap, pReqInfo->priority, (LPBYTE) pReqInfo->packet->GetEncodedData(), pReqInfo->packet->GetEncodedDataLength()); } else { rc = g_pMCSIntf->SendDataRequest( pReqInfo->channel_id, m_pMCSSap, pReqInfo->priority, (LPBYTE) pReqInfo->packet->GetEncodedData(), pReqInfo->packet->GetEncodedDataLength()); } if (rc == MCS_NO_ERROR) { pReqInfo->packet->Unlock(); delete pReqInfo; } else { TRACE_OUT(("MCSUser::FlushMessageQueue: Could not send queued packet data in this heartbeat")); m_OutgoingPDUQueue.Prepend(pReqInfo); break; // breaking out of the for loop } } return (! (m_OutgoingPDUQueue.IsEmpty() && m_EjectedNodeAlarmList2.IsEmpty())); } /* * MCSUser::SetChildUserID() * * Public Function Description: * This function is called by the conference object to pass on the user id * of the child node to the user object. The user object inserts this * user id into a user id list of it's children which it maintains. */ void MCSUser::SetChildUserIDAndConnection ( UserID child_user_id, ConnectionHandle child_connection_handle) { TRACE_OUT(("MCSUser::SetChildUserID: Adding Child userid=0x%04x to the list", (UINT) child_user_id)); TRACE_OUT(("MCSUser::SetChildUserID: Adding Child Connection=%d to the list", (UINT) child_connection_handle)); m_ChildUidConnHdlList2.Append(child_user_id, child_connection_handle); } /* * GCCError InitiateEjectionFromConference() * * Private Function Description: * This internal routine kicks of the process of ejecting this node * from the conference. This includes ejecting all the nodes below * this node and waiting for their disconnect indications to come back * in. * * Formal Parameters: * reason - (i) Reason for ejection. * * Return Value * GCC_NO_ERROR - No error occured. * GCC_ALLOCATION_FAILURE - A resource error occured. * * Side Effects * None. * * Caveats * None. */ GCCError MCSUser::InitiateEjectionFromConference (GCCReason reason) { GCCError error_value = GCC_NO_ERROR; GCCPDU gcc_pdu; PPacket packet; PacketError packet_error; PAlarm alarm = NULL; m_fEjectionPending = TRUE; m_eEjectReason = reason; if (m_ChildUidConnHdlList2.IsEmpty() == FALSE) { UserID uid; gcc_pdu.choice = INDICATION_CHOSEN; gcc_pdu.u.indication.choice = CONFERENCE_EJECT_USER_INDICATION_CHOSEN; gcc_pdu.u.indication.u.conference_eject_user_indication.reason = ::TranslateGCCReasonToEjectInd( GCC_REASON_HIGHER_NODE_EJECTED); m_ChildUidConnHdlList2.Reset(); while (m_ChildUidConnHdlList2.Iterate(&uid)) { // Get the Node to eject from the list of child nodes gcc_pdu.u.indication.u.conference_eject_user_indication.node_to_eject = uid; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, &gcc_pdu, GCC_PDU, TRUE, &packet_error); if ((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { AddToMCSMessageQueue(packet, BROADCAST_CHANNEL_ID, HIGH_PRIORITY, TRUE); DBG_SAVE_FILE_LINE alarm = new Alarm (EJECTED_NODE_TIMER_DURATION); if (alarm != NULL) { /* ** Here we save the alarm in a list of ejected ** nodes. This alarm is used to cleanup any ** misbehaving node. */ m_EjectedNodeAlarmList2.Append(uid, alarm); } else { error_value = GCC_ALLOCATION_FAILURE; break; } } else { error_value = GCC_ALLOCATION_FAILURE; delete packet; break; } } } else { m_pConf->ProcessEjectUserIndication(m_eEjectReason); } return (error_value); } /* * UINT ProcessSendDataIndication() * * Private Function Description: * This function is called when the user object gets send data indications * from below. It finds out the message type and decodes the pdu in the * user data field of send data indications. Based on the type of decoded * pdu it take the necessary actions. * * Formal Parameters: * send_data_info - (i) Send data structure to process. * * Return Value * MCS_NO_ERROR is always returned from this routine. * * Side Effects * None. * * Caveats * None. */ UINT MCSUser::ProcessSendDataIndication(PSendData send_data_info) { PPacket packet; PacketError packet_error; PGCCPDU gcc_pdu; GCCError error_value = GCC_NO_ERROR; UserID initiator; DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPBYTE)send_data_info->user_data.value, send_data_info->user_data.length, GCC_PDU, TRUE, &packet_error); if(packet != NULL && packet_error == PACKET_NO_ERROR) { initiator = send_data_info->initiator; gcc_pdu = (PGCCPDU)packet->GetDecodedData(); switch(gcc_pdu->choice) { case INDICATION_CHOSEN: // Data PDU switch(gcc_pdu->u.indication.choice) { case USER_ID_INDICATION_CHOSEN: { /* * Sequence number and User Id sent by the child * node after a successful conference create or * join. */ m_pConf->ProcessUserIDIndication( gcc_pdu->u.indication.u.user_id_indication.tag, initiator); } break; case ROSTER_UPDATE_INDICATION_CHOSEN: if(send_data_info->channel_id == m_nidMyself) { // // We only process the roster update if the conference is // established. // if (m_pConf->IsConfEstablished()) { m_pConf->ProcessRosterUpdatePDU(gcc_pdu, initiator); } } break; case CONFERENCE_TIME_INQUIRE_INDICATION_CHOSEN: g_pControlSap->ConfTimeInquireIndication( m_pConf->GetConfID(), gcc_pdu->u.indication.u.conference_time_inquire_indication.time_is_node_specific, initiator); break; case CONFERENCE_TIME_EXTEND_INDICATION_CHOSEN: #ifdef JASPER ProcessConferenceExtendIndicationPDU( &gcc_pdu->u.indication.u. conference_time_extend_indication, initiator); #endif // JASPER break; case APPLICATION_INVOKE_INDICATION_CHOSEN: ProcessApplicationInvokeIndication( &gcc_pdu->u.indication.u. application_invoke_indication, initiator); break; case TEXT_MESSAGE_INDICATION_CHOSEN: #ifdef JASPER if (ProcessTextMessageIndication( &gcc_pdu->u.indication.u. text_message_indication, initiator) != GCC_NO_ERROR) { error_value = GCC_ALLOCATION_FAILURE; } #endif // JASPER break; case CONFERENCE_LOCK_INDICATION_CHOSEN: m_pConf->ProcessConferenceLockIndication(initiator); break; case CONFERENCE_UNLOCK_INDICATION_CHOSEN: m_pConf->ProcessConferenceUnlockIndication(initiator); break; default: ERROR_OUT(("User::ProcessSendDataIndication Unsupported PDU")); break; } // switch(gcc_pdu->u.indication.choice) break; case REQUEST_CHOSEN: // Connection(control) PDU switch(gcc_pdu->u.request.choice) { case CONFERENCE_JOIN_REQUEST_CHOSEN: ProcessConferenceJoinRequestPDU( &gcc_pdu->u.request.u.conference_join_request, send_data_info); break; case CONFERENCE_TERMINATE_REQUEST_CHOSEN: ProcessConferenceTerminateRequestPDU( &gcc_pdu->u.request.u. conference_terminate_request, send_data_info); break; case CONFERENCE_EJECT_USER_REQUEST_CHOSEN: ProcessConferenceEjectUserRequestPDU( &gcc_pdu->u.request.u. conference_eject_user_request, send_data_info); break; case REGISTRY_ALLOCATE_HANDLE_REQUEST_CHOSEN: ProcessRegistryAllocateHandleRequestPDU( &gcc_pdu->u.request.u. registry_allocate_handle_request, send_data_info); break; case CONFERENCE_LOCK_REQUEST_CHOSEN: m_pConf->ProcessConferenceLockRequest(initiator); break; case CONFERENCE_UNLOCK_REQUEST_CHOSEN: m_pConf->ProcessConferenceUnlockRequest(initiator); break; case CONFERENCE_TRANSFER_REQUEST_CHOSEN: ProcessTransferRequestPDU( &gcc_pdu->u.request.u.conference_transfer_request, send_data_info); break; case CONFERENCE_ADD_REQUEST_CHOSEN: ProcessAddRequestPDU ( &gcc_pdu->u.request.u.conference_add_request, send_data_info); break; case REGISTRY_REGISTER_CHANNEL_REQUEST_CHOSEN: case REGISTRY_ASSIGN_TOKEN_REQUEST_CHOSEN: case REGISTRY_SET_PARAMETER_REQUEST_CHOSEN: case REGISTRY_DELETE_ENTRY_REQUEST_CHOSEN: case REGISTRY_RETRIEVE_ENTRY_REQUEST_CHOSEN: case REGISTRY_MONITOR_ENTRY_REQUEST_CHOSEN: ProcessRegistryRequestPDU( gcc_pdu, send_data_info); break; default: ERROR_OUT(("User::ProcessSendDataIndication this pdu choice is not supported")); break; } // switch(gcc_pdu->u.request.choice) break; case RESPONSE_CHOSEN: // Connection(control) PDU switch(gcc_pdu->u.response.choice) { case CONFERENCE_JOIN_RESPONSE_CHOSEN: /* This comes from top provider to the intermediate * gcc provider which has to pass it on to the node * that made a join request. */ ProcessConferenceJoinResponsePDU( &gcc_pdu->u.response.u. conference_join_response); break; case CONFERENCE_TERMINATE_RESPONSE_CHOSEN: ProcessConferenceTerminateResponsePDU( &gcc_pdu->u.response.u. conference_terminate_response); break; case CONFERENCE_EJECT_USER_RESPONSE_CHOSEN: ProcessConferenceEjectUserResponsePDU( &gcc_pdu->u.response.u. conference_eject_user_response); break; case REGISTRY_RESPONSE_CHOSEN: ProcessRegistryResponsePDU( &gcc_pdu->u.response.u.registry_response); break; case REGISTRY_ALLOCATE_HANDLE_RESPONSE_CHOSEN: ProcessRegistryAllocateHandleResponsePDU( &gcc_pdu->u.response.u. registry_allocate_handle_response); break; case CONFERENCE_LOCK_RESPONSE_CHOSEN: #ifdef JASPER { GCCResult result; result = ::TranslateLockResultToGCCResult(gcc_pdu->u.response.u.conference_lock_response.result); g_pControlSap->ConfLockConfirm(result, m_pConf->GetConfID()); } #endif // JASPER break; case CONFERENCE_UNLOCK_RESPONSE_CHOSEN: #ifdef JASPER { GCCResult result; result = ::TranslateUnlockResultToGCCResult(gcc_pdu->u.response.u.conference_unlock_response.result); g_pControlSap->ConfUnlockConfirm(result, m_pConf->GetConfID()); } #endif // JASPER break; case CONFERENCE_TRANSFER_RESPONSE_CHOSEN: #ifdef JASPER ProcessTransferResponsePDU( &gcc_pdu->u.response.u.conference_transfer_response); #endif // JASPER break; case CONFERENCE_ADD_RESPONSE_CHOSEN: ProcessAddResponsePDU( &gcc_pdu->u.response.u.conference_add_response); break; case FUNCTION_NOT_SUPPORTED_RESPONSE_CHOSEN: ProcessFunctionNotSupported ( (UINT) gcc_pdu->u.response.u.function_not_supported_response.request.choice); break; // other cases to be added as we go along. default: ERROR_OUT(("User::ProcessSendDataIndication this pdu choice is not supported")); break; } // switch(gcc_pdu->u.response.choice) break; default: ERROR_OUT(("User::ProcessSendDataIndication this pdu type")); break; } // switch(gcc_pdu->choice) packet->Unlock(); } else { delete packet; error_value = GCC_ALLOCATION_FAILURE; } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } return(MCS_NO_ERROR); } /* * void ProcessConferenceJoinRequestPDU () * * Private Function Description: * This PDU comes from below (intermediate directly connected node) to the * top gcc provider. Pull out the tag number and user id from the * pdu and store in a list. * * Formal Parameters: * join_request - (i) Join request PDU structure to process. * send_data_info - (i) Send data structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessConferenceJoinRequestPDU( PConferenceJoinRequest join_request, PSendData send_data_info) { GCCError rc = GCC_NO_ERROR; UserJoinRequestInfo join_request_info; /* ** Build all the containers to be used in the join request info structure. */ // Build the convener password container if ((join_request->bit_mask & CJRQ_CONVENER_PASSWORD_PRESENT) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE join_request_info.convener_password = new CPassword( &join_request->cjrq_convener_password, &rc); if (join_request_info.convener_password == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { join_request_info.convener_password = NULL; } // Build the password challenge container if ((join_request->bit_mask & CJRQ_PASSWORD_PRESENT) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE join_request_info.password_challenge = new CPassword( &join_request->cjrq_password, &rc); if (join_request_info.password_challenge == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { join_request_info.password_challenge = NULL; } // Build the caller identifier container if ((join_request->bit_mask & CJRQ_CALLER_ID_PRESENT) && (rc == GCC_NO_ERROR)) { if (NULL == (join_request_info.pwszCallerID = ::My_strdupW2( join_request->cjrq_caller_id.length, join_request->cjrq_caller_id.value))) { rc = GCC_ALLOCATION_FAILURE; } } else { join_request_info.pwszCallerID = NULL; } // Build the password challenge container if ((join_request->bit_mask & CJRQ_USER_DATA_PRESENT) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE join_request_info.user_data_list = new CUserDataListContainer(join_request->cjrq_user_data, &rc); if (join_request_info.user_data_list == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { join_request_info.user_data_list = NULL; } if (rc == GCC_NO_ERROR) { m_ConfJoinResponseList2.Append(send_data_info->initiator, join_request->tag); join_request_info.sender_id = send_data_info->initiator; g_pControlSap->ForwardedConfJoinIndication( join_request_info.sender_id, m_pConf->GetConfID(), join_request_info.convener_password, join_request_info.password_challenge, join_request_info.pwszCallerID, join_request_info.user_data_list); } // Free up the containers allocated above if (join_request_info.convener_password != NULL) { join_request_info.convener_password->Release(); } if (join_request_info.password_challenge != NULL) { join_request_info.password_challenge->Release(); } delete join_request_info.pwszCallerID; if (join_request_info.user_data_list != NULL) { join_request_info.user_data_list->Release(); } if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void ProcessConferenceJoinResponsePDU () * * Private Function Description: * This comes from top provider to the intermediate gcc provider which has * to pass it on to the node that made a join request. * * Formal Parameters: * join_response - (i) Join response PDU structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessConferenceJoinResponsePDU( PConferenceJoinResponse join_response) { GCCError rc = GCC_NO_ERROR; UserJoinResponseInfo join_response_info; // Store the password data in the join response info structure if ((join_response->bit_mask & CJRS_PASSWORD_PRESENT) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE join_response_info.password_challenge = new CPassword( &join_response->cjrs_password, &rc); if (join_response_info.password_challenge == NULL) { rc = GCC_NO_ERROR; } } else { join_response_info.password_challenge = NULL; } // Store the user data in the join response info structure if ((join_response->bit_mask & CJRS_USER_DATA_PRESENT) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE join_response_info.user_data_list = new CUserDataListContainer(join_response->cjrs_user_data, &rc); if (join_response_info.user_data_list == NULL) { rc = GCC_NO_ERROR; } } else { join_response_info.user_data_list = NULL; } if (rc == GCC_NO_ERROR) { join_response_info.connection_handle = (ConnectionHandle)join_response->tag; join_response_info.result = ::TranslateJoinResultToGCCResult(join_response->result); m_pConf->ProcessConfJoinResponse(&join_response_info); } // Free up the containers allocated above if (join_response_info.password_challenge != NULL) join_response_info.password_challenge->Release(); if (join_response_info.user_data_list != NULL) join_response_info.user_data_list->Release(); // Cleanup after any allocation failures. if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } /* * void ProcessConferenceTerminateRequestPDU() * * Private Function Description: * This routine is responsible for processing an incoming Conference * Terminate Request PDU. * * Formal Parameters: * terminate_request - (i) Terminate request PDU structure to process. * send_data_info - (i) Send data structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: ProcessConferenceTerminateRequestPDU ( PConferenceTerminateRequest terminate_request, PSendData send_data_info ) { m_pConf->ProcessTerminateRequest( send_data_info->initiator, ::TranslateTerminateRqReasonToGCCReason(terminate_request->reason)); } /* * void ProcessConferenceEjectUserRequestPDU() * * Private Function Description: * This routine is responsible for processing an incoming Conference * eject user request PDU. * * Formal Parameters: * eject_user_request - (i) Eject user request PDU structure to process. * send_data_info - (i) Send data structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessConferenceEjectUserRequestPDU( PConferenceEjectUserRequest eject_user_request, PSendData send_data_info) { UserEjectNodeRequestInfo eject_node_request; eject_node_request.requester_id = send_data_info->initiator; eject_node_request.node_to_eject = eject_user_request->node_to_eject; eject_node_request.reason = GCC_REASON_NODE_EJECTED; m_pConf->ProcessEjectUserRequest(&eject_node_request); } /* * void ProcessConferenceTerminateResponsePDU() * * Private Function Description: * This routine is responsible for processing an incoming Conference * terminate response PDU. * * Formal Parameters: * terminate_response - (i) Terminate response PDU structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessConferenceTerminateResponsePDU( PConferenceTerminateResponse terminate_response) { GCCResult result = ::TranslateTerminateResultToGCCResult(terminate_response->result); // // If the terminate was successful, go ahead and set the // conference to not established. // if (result == GCC_RESULT_SUCCESSFUL) { m_pConf->ConfIsOver(); } g_pControlSap->ConfTerminateConfirm(m_pConf->GetConfID(), result); } /* * void ProcessConferenceEjectUserResponsePDU() * * Private Function Description: * This routine is responsible for processing an incoming Conference * Eject User response PDU. * * Formal Parameters: * eject_user_response - (i) Eject user response PDU structure to * process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessConferenceEjectUserResponsePDU( PConferenceEjectUserResponse eject_user_response) { UserEjectNodeResponseInfo eject_node_response; eject_node_response.node_to_eject = eject_user_response->node_to_eject; eject_node_response.result = ::TranslateEjectResultToGCCResult( eject_user_response->result); m_pConf->ProcessEjectUserResponse(&eject_node_response); } /* * void ProcessRegistryRequest() * * Private Function Description: * This routine is responsible for processing an incoming Registry * request PDU. * * Formal Parameters: * gcc_pdu - (i) This is the PDU structure to process. * send_data_info - (i) Send data structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: ProcessRegistryRequestPDU ( PGCCPDU gcc_pdu, PSendData send_data_info ) { CRegistry *pAppReg = m_pConf->GetRegistry(); if (NULL != pAppReg) { GCCError rc = GCC_ALLOCATION_FAILURE; CRegKeyContainer *pRegKey = NULL; switch (gcc_pdu->u.request.choice) { case REGISTRY_REGISTER_CHANNEL_REQUEST_CHOSEN: DBG_SAVE_FILE_LINE pRegKey = new CRegKeyContainer( &gcc_pdu->u.request.u.registry_register_channel_request.key, &rc); if ((pRegKey != NULL) && (rc == GCC_NO_ERROR)) { pAppReg->ProcessRegisterChannelPDU( pRegKey, gcc_pdu->u.request.u.registry_register_channel_request.channel_id, send_data_info->initiator, // Requester node id gcc_pdu->u.request.u.registry_register_channel_request.entity_id); } else { // rc = GCC_ALLOCATION_FAILURE; } break; case REGISTRY_ASSIGN_TOKEN_REQUEST_CHOSEN: DBG_SAVE_FILE_LINE pRegKey = new CRegKeyContainer( &gcc_pdu->u.request.u.registry_assign_token_request.registry_key, &rc); if ((pRegKey != NULL) && (rc == GCC_NO_ERROR)) { pAppReg->ProcessAssignTokenPDU( pRegKey, send_data_info->initiator, // Requester node id gcc_pdu->u.request.u.registry_assign_token_request.entity_id); } else { // rc = GCC_ALLOCATION_FAILURE; } break; case REGISTRY_SET_PARAMETER_REQUEST_CHOSEN: DBG_SAVE_FILE_LINE pRegKey = new CRegKeyContainer( &gcc_pdu->u.request.u.registry_set_parameter_request.key, &rc); if ((pRegKey != NULL) && (rc == GCC_NO_ERROR)) { OSTR oszParamValue; LPOSTR poszParamValue; GCCModificationRights eRights; if (gcc_pdu->u.request.u.registry_set_parameter_request. registry_set_parameter.length != 0) { poszParamValue = &oszParamValue; oszParamValue.length = gcc_pdu->u.request.u.registry_set_parameter_request. registry_set_parameter.length; oszParamValue.value = gcc_pdu->u.request.u.registry_set_parameter_request. registry_set_parameter.value; } else { poszParamValue = NULL; } if (gcc_pdu->u.request.u.registry_set_parameter_request. bit_mask & PARAMETER_MODIFY_RIGHTS_PRESENT) { eRights = (GCCModificationRights)gcc_pdu->u.request.u. registry_set_parameter_request.parameter_modify_rights; } else { eRights = GCC_NO_MODIFICATION_RIGHTS_SPECIFIED; } pAppReg->ProcessSetParameterPDU( pRegKey, poszParamValue, eRights, send_data_info->initiator, // Requester node id gcc_pdu->u.request.u.registry_set_parameter_request.entity_id); } else { // rc = GCC_ALLOCATION_FAILURE; } break; case REGISTRY_RETRIEVE_ENTRY_REQUEST_CHOSEN: DBG_SAVE_FILE_LINE pRegKey = new CRegKeyContainer( &gcc_pdu->u.request.u.registry_retrieve_entry_request.key, &rc); if ((pRegKey != NULL) && (rc == GCC_NO_ERROR)) { pAppReg->ProcessRetrieveEntryPDU( pRegKey, send_data_info->initiator, // Requester node id gcc_pdu->u.request.u.registry_retrieve_entry_request.entity_id); } else { // rc = GCC_ALLOCATION_FAILURE; } break; case REGISTRY_DELETE_ENTRY_REQUEST_CHOSEN: DBG_SAVE_FILE_LINE pRegKey = new CRegKeyContainer( &gcc_pdu->u.request.u.registry_delete_entry_request.key, &rc); if ((pRegKey != NULL) && (rc == GCC_NO_ERROR)) { pAppReg->ProcessDeleteEntryPDU ( pRegKey, send_data_info->initiator, // Requester node id gcc_pdu->u.request.u.registry_delete_entry_request.entity_id); } else { // rc = GCC_ALLOCATION_FAILURE; } break; case REGISTRY_MONITOR_ENTRY_REQUEST_CHOSEN: DBG_SAVE_FILE_LINE pRegKey = new CRegKeyContainer( &gcc_pdu->u.request.u.registry_monitor_entry_request.key, &rc); if ((pRegKey != NULL) && (rc == GCC_NO_ERROR)) { pAppReg->ProcessMonitorEntryPDU( pRegKey, send_data_info->initiator, // Requester node id gcc_pdu->u.request.u.registry_monitor_entry_request.entity_id); } else { // rc = GCC_ALLOCATION_FAILURE; } break; } if (NULL != pRegKey) { pRegKey->Release(); } // Handle resource errors if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } // if pAppReg != NULL } /* * void ProcessRegistryAllocateHandleRequestPDU() * * Private Function Description: * This routine is responsible for processing an incoming Allocate * Handle request PDU. * * Formal Parameters: * allocate_handle_request - (i) This is the PDU structure to process. * send_data_info - (i) Send data structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: ProcessRegistryAllocateHandleRequestPDU ( PRegistryAllocateHandleRequest allocate_handle_request, PSendData send_data_info ) { CRegistry *pAppReg = m_pConf->GetRegistry(); if (NULL != pAppReg) { pAppReg->ProcessAllocateHandleRequestPDU( allocate_handle_request->number_of_handles, allocate_handle_request->entity_id, send_data_info->initiator); } } /* * void ProcessRegistryResponsePDU() * * Private Function Description: * This routine is responsible for processing an incoming Registry * Response PDU. * * Formal Parameters: * registry_response - (i) This is the PDU structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: ProcessRegistryResponsePDU ( PRegistryResponse registry_response ) { CRegistry *pAppReg = m_pConf->GetRegistry(); if (NULL != pAppReg) { GCCError rc; UserRegistryResponseInfo urri; ::ZeroMemory(&urri, sizeof(urri)); // urri.registry_key = NULL; // urri.registry_item = NULL; DBG_SAVE_FILE_LINE urri.registry_key = new CRegKeyContainer(®istry_response->key, &rc); if ((urri.registry_key != NULL) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE urri.registry_item = new CRegItem(®istry_response->item, &rc); if ((urri.registry_item != NULL) && (rc == GCC_NO_ERROR)) { // Set up the original requester entity id urri.requester_entity_id = registry_response->entity_id; // Set up the primitive type being responded to urri.primitive_type = registry_response->primitive_type; // Set up the owner related variables if (registry_response->owner.choice == OWNED_CHOSEN) { urri.owner_node_id = registry_response->owner.u.owned.node_id; urri.owner_entity_id = registry_response->owner.u.owned.entity_id; } else { // urri.owner_node_id = 0; // urri.owner_entity_id = 0; } // Set up the modification rights if (registry_response->bit_mask & RESPONSE_MODIFY_RIGHTS_PRESENT) { urri.modification_rights = (GCCModificationRights)registry_response->response_modify_rights; } else { urri.modification_rights = GCC_NO_MODIFICATION_RIGHTS_SPECIFIED; } // Translate the result to a GCC result urri.result = ::TranslateRegistryRespToGCCResult(registry_response->result); pAppReg->ProcessRegistryResponsePDU( urri.primitive_type, urri.registry_key, urri.registry_item, urri.modification_rights, urri.requester_entity_id, urri.owner_node_id, urri.owner_entity_id, urri.result); } else { rc = GCC_ALLOCATION_FAILURE; } } else { rc = GCC_ALLOCATION_FAILURE; } if (NULL != urri.registry_key) { urri.registry_key->Release(); } if (NULL != urri.registry_item) { urri.registry_item->Release(); } // Handle any resource errors if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } // if pAppReg != NULL } /* * void ProcessAllocateHandleResponsePDU() * * Private Function Description: * This routine is responsible for processing an incoming Allocate * Handle Response PDU. * * Formal Parameters: * allocate_handle_response- (i) This is the PDU structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: ProcessRegistryAllocateHandleResponsePDU ( PRegistryAllocateHandleResponse allocate_handle_response ) { CRegistry *pAppReg = m_pConf->GetRegistry(); if (NULL != pAppReg) { pAppReg->ProcessAllocateHandleResponsePDU( allocate_handle_response->number_of_handles, allocate_handle_response->first_handle, allocate_handle_response->entity_id, (allocate_handle_response->result == RARS_RESULT_SUCCESS) ? GCC_RESULT_SUCCESSFUL : GCC_RESULT_NO_HANDLES_AVAILABLE); } } /* * void ProcessTransferRequestPDU() * * Private Function Description: * This routine is responsible for processing an incoming Transfer * request PDU. * * Formal Parameters: * transfer_request - (i) This is the PDU structure to process. * send_data_info - (i) Send data structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: ProcessTransferRequestPDU ( PConferenceTransferRequest transfer_request, PSendData send_data_info ) { GCCError rc = GCC_NO_ERROR; TransferInfo transfer_info; PSetOfTransferringNodesRq set_of_nodes; LPBYTE sub_node_list_memory = NULL; Int i; // Make sure that this node is the top provider if (GetMyNodeID() != GetTopNodeID()) return; ::ZeroMemory(&transfer_info, sizeof(transfer_info)); // First set up the conference name if (transfer_request->conference_name.choice == NAME_SELECTOR_NUMERIC_CHOSEN) { transfer_info.destination_conference_name.numeric_string = (LPSTR) transfer_request->conference_name.u.name_selector_numeric; // transfer_info.destination_conference_name.text_string = NULL; } else { // transfer_info.destination_conference_name.numeric_string = NULL; if (NULL == (transfer_info.destination_conference_name.text_string = ::My_strdupW2( transfer_request->conference_name.u.name_selector_text.length, transfer_request->conference_name.u.name_selector_text.value))) { rc = GCC_ALLOCATION_FAILURE; } } // Next set up the conference name modifier if (transfer_request->bit_mask & CTRQ_CONFERENCE_MODIFIER_PRESENT) { transfer_info.destination_conference_modifier = (LPSTR) transfer_request->ctrq_conference_modifier; } else { // transfer_info.destination_conference_modifier = NULL; } // Next set up the network address if (transfer_request->bit_mask & CTRQ_NETWORK_ADDRESS_PRESENT) { DBG_SAVE_FILE_LINE transfer_info.destination_address_list = new CNetAddrListContainer( transfer_request->ctrq_net_address, &rc); if (transfer_info.destination_address_list == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { // transfer_info.destination_address_list = NULL; } // Set up the transferring nodes list if (transfer_request->bit_mask & CTRQ_TRANSFERRING_NODES_PRESENT) { // First determine the number of nodes. set_of_nodes = transfer_request->ctrq_transferring_nodes; // transfer_info.number_of_destination_nodes = 0; while (set_of_nodes != NULL) { transfer_info.number_of_destination_nodes++; set_of_nodes = set_of_nodes->next; } // Next allocate the memory required to hold the sub nodes DBG_SAVE_FILE_LINE sub_node_list_memory = new BYTE[sizeof(UserID) * transfer_info.number_of_destination_nodes]; // Now fill in the permission list if (sub_node_list_memory != NULL) { transfer_info.destination_node_list = (PUserID) sub_node_list_memory; set_of_nodes = transfer_request->ctrq_transferring_nodes; for (i = 0; i < transfer_info.number_of_destination_nodes; i++) { transfer_info.destination_node_list[i] = set_of_nodes->value; set_of_nodes = set_of_nodes->next; } } else { ERROR_OUT(("MCSUser: ProcessTransferRequestPDU: Memory Manager Alloc Failure")); rc = GCC_ALLOCATION_FAILURE; } } else { // transfer_info.number_of_destination_nodes = 0; // transfer_info.destination_node_list = NULL; } // Set up the password if (transfer_request->bit_mask & CTRQ_PASSWORD_PRESENT) { DBG_SAVE_FILE_LINE transfer_info.password = new CPassword(&transfer_request->ctrq_password, &rc); if (transfer_info.password == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { // transfer_info.password = NULL; } // Save the sender ID transfer_info.requesting_node_id = send_data_info->initiator; if (rc == GCC_NO_ERROR) { m_pConf->ProcessConferenceTransferRequest( transfer_info.requesting_node_id, &transfer_info.destination_conference_name, transfer_info.destination_conference_modifier, transfer_info.destination_address_list, transfer_info.number_of_destination_nodes, transfer_info.destination_node_list, transfer_info.password); } else { ERROR_OUT(("MCSUser::ProcessTransferRequestPDU: Allocation Failure")); if (GCC_ALLOCATION_FAILURE == rc) { ResourceFailureHandler(); } } // Now cleanup any allocated memory if (transfer_info.destination_address_list != NULL) { transfer_info.destination_address_list->Release(); } delete sub_node_list_memory; if (transfer_info.password != NULL) { transfer_info.password->Release(); } } /* * void ProcessAddRequestPDU () * * Private Function Description: * This routine is responsible for processing an incoming Conference Add * request PDU. * * Formal Parameters: * conference_add_request - (i) This is the PDU structure to process. * send_data_info - (i) Send data structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessAddRequestPDU ( PConferenceAddRequest conference_add_request, PSendData send_data_info) { GCCError rc = GCC_NO_ERROR; AddRequestInfo add_request_info; /* ** Ignore this request if this node is NOT the Top Provider and the request ** did not come from the Top Provider. */ if (m_nidTopProvider != m_nidMyself) { if (m_nidTopProvider != send_data_info->initiator) return; } ::ZeroMemory(&add_request_info, sizeof(add_request_info)); DBG_SAVE_FILE_LINE add_request_info.network_address_list = new CNetAddrListContainer( conference_add_request->add_request_net_address, &rc); if (add_request_info.network_address_list == NULL) { rc = GCC_ALLOCATION_FAILURE; } if ((rc == GCC_NO_ERROR) && (conference_add_request->bit_mask & CARQ_USER_DATA_PRESENT)) { DBG_SAVE_FILE_LINE add_request_info.user_data_list = new CUserDataListContainer(conference_add_request->carq_user_data, &rc); if (add_request_info.user_data_list == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { // add_request_info.user_data_list = NULL; } if (rc == GCC_NO_ERROR) { add_request_info.adding_node = (conference_add_request->bit_mask & ADDING_MCU_PRESENT) ? conference_add_request->adding_mcu : 0; add_request_info.requesting_node = conference_add_request->requesting_node; add_request_info.add_request_tag = (TagNumber)conference_add_request->tag; m_pConf->ProcessConferenceAddRequest( add_request_info.network_address_list, add_request_info.user_data_list, add_request_info.adding_node, add_request_info.add_request_tag, add_request_info.requesting_node); } else { ERROR_OUT(("MCSUser::ProcessAddRequestPDU: Allocation Failure")); if (GCC_ALLOCATION_FAILURE == rc) { ResourceFailureHandler(); } } if (add_request_info.network_address_list != NULL) { add_request_info.network_address_list->Release(); } if (add_request_info.user_data_list != NULL) { add_request_info.user_data_list->Release(); } } /* * void ProcessTransferResponsePDU() * * Private Function Description: * This routine is responsible for processing an incoming Conference * Transfer response PDU. * * Formal Parameters: * transfer_response - (i) This is the PDU structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ #ifdef JASPER void MCSUser::ProcessTransferResponsePDU ( PConferenceTransferResponse transfer_response) { GCCError rc = GCC_NO_ERROR; TransferInfo transfer_info; PSetOfTransferringNodesRs set_of_nodes; LPBYTE sub_node_list_memory = NULL; Int i; ::ZeroMemory(&transfer_info, sizeof(transfer_info)); // First set up the conference name if (transfer_response->conference_name.choice == NAME_SELECTOR_NUMERIC_CHOSEN) { transfer_info.destination_conference_name.numeric_string = (LPSTR) transfer_response->conference_name.u.name_selector_numeric; // transfer_info.destination_conference_name.text_string = NULL; } else { // transfer_info.destination_conference_name.numeric_string = NULL; if (NULL == (transfer_info.destination_conference_name.text_string = ::My_strdupW2( transfer_response->conference_name.u.name_selector_text.length, transfer_response->conference_name.u.name_selector_text.value))) { rc = GCC_ALLOCATION_FAILURE; } } // Next set up the conference name modifier if (transfer_response->bit_mask & CTRS_CONFERENCE_MODIFIER_PRESENT) { transfer_info.destination_conference_modifier = (LPSTR) transfer_response->ctrs_conference_modifier; } else { // transfer_info.destination_conference_modifier = NULL; } // Set up the transferring nodes list if (transfer_response->bit_mask & CTRS_TRANSFERRING_NODES_PRESENT) { // First determine the number of nodes. set_of_nodes = transfer_response->ctrs_transferring_nodes; // transfer_info.number_of_destination_nodes = 0; while (set_of_nodes != NULL) { transfer_info.number_of_destination_nodes++; set_of_nodes = set_of_nodes->next; } // Next allocate the memory required to hold the sub nodes DBG_SAVE_FILE_LINE sub_node_list_memory = new BYTE[sizeof(UserID) * transfer_info.number_of_destination_nodes]; // Now fill in the permission list if (sub_node_list_memory != NULL) { transfer_info.destination_node_list = (PUserID) sub_node_list_memory; set_of_nodes = transfer_response->ctrs_transferring_nodes; for (i = 0; i < transfer_info.number_of_destination_nodes; i++) { transfer_info.destination_node_list[i] = set_of_nodes->value; set_of_nodes = set_of_nodes->next; } } else { ERROR_OUT(("MCSUser: ProcessTransferResponsePDU: Memory Manager Alloc Failure")); rc = GCC_ALLOCATION_FAILURE; } } else { // transfer_info.number_of_destination_nodes = 0; // transfer_info.destination_node_list = NULL; } // Save the result transfer_info.result = (transfer_response->result == CTRANS_RESULT_SUCCESS) ? GCC_RESULT_SUCCESSFUL : GCC_RESULT_INVALID_REQUESTER; if (rc == GCC_NO_ERROR) { g_pControlSap->ConfTransferConfirm( m_pConf->GetConfID(), &transfer_info.destination_conference_name, transfer_info.destination_conference_modifier, transfer_info.number_of_destination_nodes, transfer_info.destination_node_list, transfer_info.result); } else { ERROR_OUT(("MCSUser::ProcessTransferResponsePDU: Allocation Failure")); if (GCC_ALLOCATION_FAILURE == rc) { ResourceFailureHandler(); } } // Now cleanup any allocated memory delete sub_node_list_memory; } #endif // JASPER /* * void ProcessAddResponsePDU () * * Private Function Description: * This routine is responsible for processing an incoming Conference * Add response PDU. * * Formal Parameters: * conference_add_response - (i) This is the PDU structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessAddResponsePDU ( PConferenceAddResponse conference_add_response) { GCCError error_value = GCC_NO_ERROR; AddResponseInfo add_response_info; if (conference_add_response->bit_mask & CARS_USER_DATA_PRESENT) { DBG_SAVE_FILE_LINE add_response_info.user_data_list = new CUserDataListContainer(conference_add_response->cars_user_data, &error_value); if (add_response_info.user_data_list == NULL) { error_value = GCC_ALLOCATION_FAILURE; } } else { add_response_info.user_data_list = NULL; } if (error_value == GCC_NO_ERROR) { add_response_info.add_request_tag = (TagNumber)conference_add_response->tag; add_response_info.result = ::TranslateAddResultToGCCResult(conference_add_response->result); m_pConf->ProcessConfAddResponse(&add_response_info); } else { ERROR_OUT(("MCSUser::ProcessAddResponsePDU: Allocation Failure")); if (GCC_ALLOCATION_FAILURE == error_value) { ResourceFailureHandler(); } } if (add_response_info.user_data_list != NULL) { add_response_info.user_data_list->Release(); } } /* * void ProcessFunctionNotSupported () * * Private Function Description: * This routine is responsible for processing responses for request that * are not supported at the node that the request was directed toward. * * Formal Parameters: * request_choice - (i) This is the request that is not supported. * * Return Value * None. * * Side Effects * None. * * Caveats * The existance of this routine does not mean that this provider does * not support it. It only means that the node which received the * request does not support it. */ void MCSUser:: ProcessFunctionNotSupported ( UINT request_choice ) { switch (request_choice) { case CONFERENCE_LOCK_REQUEST_CHOSEN: #ifdef JASPER g_pControlSap->ConfLockConfirm(GCC_RESULT_LOCKED_NOT_SUPPORTED, m_pConf->GetConfID()); #endif // JASPER break; case CONFERENCE_UNLOCK_REQUEST_CHOSEN: #ifdef JASPER g_pControlSap->ConfUnlockConfirm(GCC_RESULT_UNLOCK_NOT_SUPPORTED, m_pConf->GetConfID()); #endif // JASPER break; default: ERROR_OUT(("MCSUser: ProcessFunctionNotSupported: " "Error: Illegal request is unsupported")); break; } } /* * UINT ProcessUniformSendDataIndication () * * Private Function Description: * This function is called when the user object gets send data indications * from below. It finds out the message type and decodes the pdu in the * user data field of send data indications. Based on the type of decoded * pdu it take the necessary actions. * This routine is responsible for processing responses for request that * are not supported at the node that the request was directed toward. * * Formal Parameters: * send_data_info - (i) This is the MCS data structure to process. * * Return Value * MCS_NO_ERROR is always returned. * * Side Effects * None. * * Caveats * None. */ UINT MCSUser::ProcessUniformSendDataIndication( PSendData send_data_info) { PPacket packet; PacketError packet_error; PGCCPDU gcc_pdu; GCCError error_value = GCC_NO_ERROR; UserID initiator; TRACE_OUT(("User: UniformSendDataInd: length = %d", send_data_info->user_data.length)); DBG_SAVE_FILE_LINE packet = new Packet((PPacketCoder) g_GCCCoder, PACKED_ENCODING_RULES, (LPBYTE)send_data_info->user_data.value, send_data_info->user_data.length, GCC_PDU, TRUE, &packet_error); if((packet != NULL) && (packet_error == PACKET_NO_ERROR)) { initiator = send_data_info->initiator; gcc_pdu = (PGCCPDU)packet->GetDecodedData(); switch (gcc_pdu->choice) { case INDICATION_CHOSEN: // Data PDU switch(gcc_pdu->u.indication.choice) { case CONFERENCE_TERMINATE_INDICATION_CHOSEN: /* ** Note that we allow the top provider to process ** this message so that it can set up its own ** node for termination in a generic way. */ ProcessConferenceTerminateIndicationPDU ( &gcc_pdu->u.indication.u. conference_terminate_indication, initiator); break; case CONFERENCE_EJECT_USER_INDICATION_CHOSEN: /* ** Do not decode a packet that was sent uniformly ** from this node. */ if (initiator != m_nidMyself) { ProcessConferenceEjectUserIndicationPDU ( &gcc_pdu->u.indication.u. conference_eject_user_indication, initiator); } break; case ROSTER_UPDATE_INDICATION_CHOSEN: /* ** Do not decode a packet that was sent uniformly ** from this node. */ if ((initiator != m_nidMyself) && (send_data_info->channel_id == BROADCAST_CHANNEL_ID)) { // // We only process the roster update if the conference is // established. // if (m_pConf->IsConfEstablished()) { m_pConf->ProcessRosterUpdatePDU(gcc_pdu, initiator); } } break; case CONFERENCE_LOCK_INDICATION_CHOSEN: m_pConf->ProcessConferenceLockIndication(initiator); break; case CONFERENCE_UNLOCK_INDICATION_CHOSEN: m_pConf->ProcessConferenceUnlockIndication(initiator); break; case CONDUCTOR_ASSIGN_INDICATION_CHOSEN: m_pConf->ProcessConductorAssignIndication( gcc_pdu->u.indication.u.conductor_assign_indication.user_id, initiator); break; case CONDUCTOR_RELEASE_INDICATION_CHOSEN: if (initiator != m_nidMyself) { m_pConf->ProcessConductorReleaseIndication(initiator); } break; case CONDUCTOR_PERMISSION_ASK_INDICATION_CHOSEN: #ifdef JASPER /* ** Do not decode a packet that was sent uniformly ** from this node. */ if (initiator != m_nidMyself) { PermitAskIndicationInfo indication_info; indication_info.sender_id = initiator; indication_info.permission_is_granted = gcc_pdu->u.indication.u. conductor_permission_ask_indication. permission_is_granted; m_pConf->ProcessConductorPermitAskIndication(&indication_info); } #endif // JASPER break; case CONDUCTOR_PERMISSION_GRANT_INDICATION_CHOSEN: ProcessPermissionGrantIndication( &(gcc_pdu->u.indication.u. conductor_permission_grant_indication), initiator); break; case CONFERENCE_TIME_REMAINING_INDICATION_CHOSEN: #ifdef JASPER ProcessTimeRemainingIndicationPDU ( &gcc_pdu->u.indication.u. conference_time_remaining_indication, initiator); #endif // JASPER break; case APPLICATION_INVOKE_INDICATION_CHOSEN: ProcessApplicationInvokeIndication( &gcc_pdu->u.indication.u. application_invoke_indication, initiator); break; case TEXT_MESSAGE_INDICATION_CHOSEN: #ifdef JASPER if (ProcessTextMessageIndication( &gcc_pdu->u.indication.u. text_message_indication, initiator) != GCC_NO_ERROR) { error_value = GCC_ALLOCATION_FAILURE; } #endif // JASPER break; case CONFERENCE_ASSISTANCE_INDICATION_CHOSEN: #ifdef JASPER ProcessConferenceAssistanceIndicationPDU( &gcc_pdu->u.indication.u. conference_assistance_indication, initiator); #endif // JASPER break; case REGISTRY_MONITOR_ENTRY_INDICATION_CHOSEN: /* ** Do not decode this packet if it was sent ** uniformly from this node. */ if (initiator != m_nidMyself) { ProcessRegistryMonitorIndicationPDU ( &gcc_pdu->u.indication.u. registry_monitor_entry_indication, initiator); } break; case CONFERENCE_TRANSFER_INDICATION_CHOSEN: #ifdef JASPER /* ** Do not decode this packet if it was not sent ** from the top provider. */ if (initiator == m_nidTopProvider) { ProcessTransferIndicationPDU ( &gcc_pdu->u.indication.u. conference_transfer_indication); } #endif // JASPER break; default: ERROR_OUT(("MCSUser::ProcessSendDataIndication" "Unsupported PDU")); break; } // switch(gcc_pdu->u.indication.choice) break; default: ERROR_OUT(("MCSUser::ProcessUniformSendDataIndication. wrong pdu type ")); break; } packet->Unlock(); } else { delete packet; error_value = GCC_ALLOCATION_FAILURE; } if (error_value == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } return (MCS_NO_ERROR); } /* * void ProcessTransferIndicationPDU () * * Private Function Description: * This routine is responsible for processing an incoming Conference * Transfer indication PDU. * * Formal Parameters: * transfer_indication - (i) This is the PDU structure to process. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ #ifdef JASPER void MCSUser:: ProcessTransferIndicationPDU ( PConferenceTransferIndication transfer_indication ) { GCCError rc = GCC_NO_ERROR; TransferInfo transfer_info; PSetOfTransferringNodesIn set_of_nodes; LPBYTE sub_node_list_memory = NULL; Int i; BOOL process_pdu = FALSE; ::ZeroMemory(&transfer_info, sizeof(transfer_info)); /* ** If there is a transferring node list we must determine if this node ** is in the list. If it isn't then the request is ignored. */ if (transfer_indication->bit_mask & CTIN_TRANSFERRING_NODES_PRESENT) { set_of_nodes = transfer_indication->ctin_transferring_nodes; while (set_of_nodes != NULL) { if (set_of_nodes->value == GetMyNodeID()) { process_pdu = TRUE; break; } set_of_nodes = set_of_nodes->next; } if (process_pdu == FALSE) { return; } } // First set up the conference name if (transfer_indication->conference_name.choice == NAME_SELECTOR_NUMERIC_CHOSEN) { transfer_info.destination_conference_name.numeric_string = (LPSTR) transfer_indication->conference_name.u.name_selector_numeric; // transfer_info.destination_conference_name.text_string = NULL; } else { // transfer_info.destination_conference_name.numeric_string = NULL; if (NULL == (transfer_info.destination_conference_name.text_string = ::My_strdupW2( transfer_indication->conference_name.u.name_selector_text.length, transfer_indication->conference_name.u.name_selector_text.value))) { rc = GCC_ALLOCATION_FAILURE; } } // Next set up the conference name modifier if (transfer_indication->bit_mask & CTIN_CONFERENCE_MODIFIER_PRESENT) { transfer_info.destination_conference_modifier = (LPSTR) transfer_indication->ctin_conference_modifier; } else { // transfer_info.destination_conference_modifier = NULL; } // Next set up the network address if (transfer_indication->bit_mask & CTIN_NETWORK_ADDRESS_PRESENT) { DBG_SAVE_FILE_LINE transfer_info.destination_address_list = new CNetAddrListContainer( transfer_indication->ctin_net_address, &rc); if (transfer_info.destination_address_list == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { // transfer_info.destination_address_list = NULL; } // Set up the transferring nodes list if (transfer_indication->bit_mask & CTIN_TRANSFERRING_NODES_PRESENT) { // First determine the number of nodes. set_of_nodes = transfer_indication->ctin_transferring_nodes; // transfer_info.number_of_destination_nodes = 0; while (set_of_nodes != NULL) { transfer_info.number_of_destination_nodes++; set_of_nodes = set_of_nodes->next; } // Next allocate the memory required to hold the sub nodes DBG_SAVE_FILE_LINE sub_node_list_memory = new BYTE[sizeof(UserID) * transfer_info.number_of_destination_nodes]; // Now fill in the permission list if (sub_node_list_memory != NULL) { transfer_info.destination_node_list = (PUserID) sub_node_list_memory; set_of_nodes = transfer_indication->ctin_transferring_nodes; for (i = 0; i < transfer_info.number_of_destination_nodes; i++) { transfer_info.destination_node_list[i] = set_of_nodes->value; set_of_nodes = set_of_nodes->next; } } else { ERROR_OUT(("MCSUser: ProcessTransferIndicationPDU: Memory Manager Alloc Failure")); rc = GCC_ALLOCATION_FAILURE; } } else { // transfer_info.number_of_destination_nodes = 0; // transfer_info.destination_node_list = NULL; } // Set up the password if (transfer_indication->bit_mask & CTIN_PASSWORD_PRESENT) { DBG_SAVE_FILE_LINE transfer_info.password = new CPassword(&transfer_indication->ctin_password, &rc); if (transfer_info.password == NULL) { rc = GCC_ALLOCATION_FAILURE; } } else { // transfer_info.password = NULL; } if (rc == GCC_NO_ERROR) { g_pControlSap->ConfTransferIndication( m_pConf->GetConfID(), &transfer_info.destination_conference_name, transfer_info.destination_conference_modifier, transfer_info.destination_address_list, transfer_info.password); } else { ERROR_OUT(("MCSUser::ProcessTransferIndicationPDU: Allocation Failure")); if (GCC_ALLOCATION_FAILURE == rc) { ResourceFailureHandler(); } } // Now cleanup any allocated memory if (NULL != transfer_info.destination_address_list) { transfer_info.destination_address_list->Release(); } delete sub_node_list_memory; if (NULL != transfer_info.password) { transfer_info.password->Release(); } } #endif // JASPER /* * void ProcessConferenceTerminateIndicationPDU() * * Private Function Description: * This routine is responsible for processing an incoming Conference * Terminate indication PDU. * * Formal Parameters: * terminate_indication - (i) This is the PDU structure to process. * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessConferenceTerminateIndicationPDU ( PConferenceTerminateIndication terminate_indication, UserID sender_id) { if (sender_id == m_nidTopProvider) { m_pConf->ProcessTerminateIndication( ::TranslateTerminateInReasonToGCCReason(terminate_indication->reason)); } } /* * void ProcessTimeRemainingIndicationPDU () * * Private Function Description: * This routine is responsible for processing an incoming Conference * Time remaining indication PDU. * * Formal Parameters: * time_remaining_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ #ifdef JASPER void MCSUser:: ProcessTimeRemainingIndicationPDU ( PConferenceTimeRemainingIndication time_remaining_indication, UserID sender_id ) { g_pControlSap->ConfTimeRemainingIndication( m_pConf->GetConfID(), sender_id, (time_remaining_indication->bit_mask & TIME_REMAINING_NODE_ID_PRESENT) ? time_remaining_indication->time_remaining_node_id : 0, time_remaining_indication->time_remaining); } #endif // JASPER /* * void ProcessConferenceAssistanceIndicationPDU () * * Private Function Description: * This routine is responsible for processing an incoming Conference * assistance indication PDU. * * Formal Parameters: * conf_assistance_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ #ifdef JASPER void MCSUser:: ProcessConferenceAssistanceIndicationPDU ( PConferenceAssistanceIndication conf_assistance_indication, UserID sender_id ) { GCCError rc = GCC_NO_ERROR; CUserDataListContainer *user_data_list = NULL; DebugEntry(MCSUser::ProcessConferenceAssistanceIndication); // Unpack the user data list if it exists if (conf_assistance_indication->bit_mask & CAIN_USER_DATA_PRESENT) { DBG_SAVE_FILE_LINE user_data_list = new CUserDataListContainer(conf_assistance_indication->cain_user_data, &rc); if (user_data_list == NULL) { rc = GCC_ALLOCATION_FAILURE; } } if (rc == GCC_NO_ERROR) { g_pControlSap->ConfAssistanceIndication( m_pConf->GetConfID(), user_data_list, sender_id); } else { ERROR_OUT(("MCSUser::ProcessConferenceAssistanceIndication: can't create CUserDataListContainer")); if (GCC_ALLOCATION_FAILURE == rc) { ResourceFailureHandler(); } } } #endif // JASPER /* * void ProcessConferenceExtendIndicationPDU() * * Private Function Description: * This routine is responsible for processing an incoming Conference * extend indication PDU. * * Formal Parameters: * conf_time_extend_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ #ifdef JASPER void MCSUser:: ProcessConferenceExtendIndicationPDU ( PConferenceTimeExtendIndication conf_time_extend_indication, UserID sender_id ) { g_pControlSap->ConfExtendIndication( m_pConf->GetConfID(), conf_time_extend_indication->time_to_extend, conf_time_extend_indication->time_is_node_specific, sender_id); } #endif // JASPER /* * void ProcessConferenceEjectUserIndicationPDU () * * Private Function Description: * This routine is responsible for processing an incoming Conference * eject user indication PDU. * * Formal Parameters: * eject_user_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessConferenceEjectUserIndicationPDU ( PConferenceEjectUserIndication eject_user_indication, UserID sender_id) { GCCError error_value = GCC_NO_ERROR; PAlarm alarm = NULL; // First check to make sure that this is the node being ejected if (eject_user_indication->node_to_eject == m_nidMyself) { /* ** Next make sure the ejection came from either the Top Provider or ** the Parent Node. */ if ((sender_id == m_nidParent) || (sender_id == m_nidTopProvider)) { TRACE_OUT(("MCSUser:ProcessEjectUserIndication: This node is ejected")); error_value = InitiateEjectionFromConference ( ::TranslateEjectIndReasonToGCCReason( eject_user_indication->reason)); } else { ERROR_OUT(("MCSUser: ProcessEjectUserIndication: Received eject from illegal node")); } } else { TRACE_OUT(("MCSUser: ProcessEjectUserIndication: Received eject for node other than mine")); /* ** If this node is a directly connected child node we insert an ** alarm in the list m_EjectedNodeAlarmList2 to disconnect it if ** it misbehaves and does not disconnect itself. Otherwise, we save ** the ejected user id in the m_EjectedNodeList to inform the local ** node of the correct reason for disconnecting (user ejected) when the ** detch user indication comes in. */ if (m_ChildUidConnHdlList2.Find(eject_user_indication->node_to_eject)) { DBG_SAVE_FILE_LINE alarm = new Alarm (EJECTED_NODE_TIMER_DURATION); if (alarm != NULL) { m_EjectedNodeAlarmList2.Append(eject_user_indication->node_to_eject, alarm); } else error_value = GCC_ALLOCATION_FAILURE; } else { /* ** Here we save the alarm in a list of ejected nodes. This ** alarm is used to cleanup any misbehaving node. Note that ** if the ejected node is not a child of this node then no ** alarm is set up to monitor the ejection. */ m_EjectedNodeList.Append(eject_user_indication->node_to_eject); } } if (error_value == GCC_ALLOCATION_FAILURE) { ERROR_OUT(("MCSUser::ProcessEjectUserIndication: Allocation Failure")); ResourceFailureHandler(); } } /* * void ProcessPermissionGrantIndication () * * Private Function Description: * This routine is responsible for processing an incoming Permission * grant indication PDU. * * Formal Parameters: * permission_grant_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessPermissionGrantIndication( PConductorPermissionGrantIndication permission_grant_indication, UserID sender_id) { GCCError error_value = GCC_NO_ERROR; UserPermissionGrantIndicationInfo grant_indication_info; PPermissionList permission_list; LPBYTE permission_list_memory = NULL; PWaitingList waiting_list; LPBYTE waiting_list_memory = NULL; UINT i; // First count the number of entries in the permission list grant_indication_info.number_granted = 0; permission_list = permission_grant_indication->permission_list; while (permission_list != NULL) { permission_list = permission_list->next; grant_indication_info.number_granted++; } TRACE_OUT(("MCSUser: ProcessPermissionGrantIndication: number_granted=%d", (UINT) grant_indication_info.number_granted)); // If a list exist allocate memory for it and copy it over. if (grant_indication_info.number_granted != 0) { // allocating space to hold permission list. DBG_SAVE_FILE_LINE permission_list_memory = new BYTE[sizeof(UserID) * grant_indication_info.number_granted]; // Now fill in the permission list if (permission_list_memory != NULL) { grant_indication_info.granted_node_list = (PUserID) permission_list_memory; permission_list = permission_grant_indication->permission_list; for (i = 0; i < grant_indication_info.number_granted; i++) { grant_indication_info.granted_node_list[i] = permission_list->value; permission_list = permission_list->next; } } else { ERROR_OUT(("MCSUser: ProcessPermissionGrantIndication: Memory Manager Alloc Failure")); error_value = GCC_ALLOCATION_FAILURE; } } else { grant_indication_info.granted_node_list = NULL; } // Now extract the waiting list information if any exist if ((error_value == GCC_NO_ERROR) && (permission_grant_indication->bit_mask & WAITING_LIST_PRESENT)) { // First count the number of entries in the waiting list grant_indication_info.number_waiting = 0; waiting_list = permission_grant_indication->waiting_list; while (waiting_list != NULL) { waiting_list = waiting_list->next; grant_indication_info.number_waiting++; } TRACE_OUT(("MCSUser: ProcessPermissionGrantIndication: number_waiting=%d", (UINT) grant_indication_info.number_waiting)); // allocating space to hold waiting list. DBG_SAVE_FILE_LINE waiting_list_memory = new BYTE[sizeof(UserID) * grant_indication_info.number_waiting]; // Now fill in the permission list if (waiting_list_memory != NULL) { grant_indication_info.waiting_node_list = (PUserID) waiting_list_memory; waiting_list = permission_grant_indication->waiting_list; for (i = 0; i < grant_indication_info.number_waiting; i++) { grant_indication_info.waiting_node_list[i] = waiting_list->value; waiting_list = waiting_list->next; } } else { error_value = GCC_ALLOCATION_FAILURE; } } else { grant_indication_info.number_waiting = 0; grant_indication_info.waiting_node_list = NULL; } /* ** If there were no memory errors, send the indication back to the ** owner object. */ if (error_value == GCC_NO_ERROR) { m_pConf->ProcessConductorPermitGrantInd(&grant_indication_info, sender_id); } else { ERROR_OUT(("MCSUser::ProcessPermissionGrantIndication: Alloc Failed")); if (GCC_ALLOCATION_FAILURE == error_value) { ResourceFailureHandler(); } } // Free up any memory used in this call delete permission_list_memory; delete waiting_list_memory; } /* * MCSUser::GetUserIDFromConnection() * * Public Function Description: * This function returns the Node ID associated with the specified * connection handle. It returns zero if the connection handle is * not a child connection of this node. */ UserID MCSUser::GetUserIDFromConnection(ConnectionHandle connection_handle) { ConnectionHandle hConn; UserID uid; m_ChildUidConnHdlList2.Reset(); while (NULL != (hConn = m_ChildUidConnHdlList2.Iterate(&uid))) { if (hConn == connection_handle) { return uid; } } return 0; } /* * MCSUser::UserDisconnectIndication() * * Public Function Description: * This function informs the user object when a Node disconnects from * the conference. This gives the user object a chance to clean up * its internal information base. */ void MCSUser::UserDisconnectIndication(UserID disconnected_user) { PAlarm lpAlarm; /* ** If this node has a pending ejection we will go ahead and remove the ** ejected node from the list. Once all child nodes have disconnected ** we will inform the owner object of the ejection. */ if (m_fEjectionPending) { // Delete the Alarm if it exists if (NULL != (lpAlarm = m_EjectedNodeAlarmList2.Remove(disconnected_user))) { delete lpAlarm; /* ** Here we must check to see if there are anymore active alarms ** in the list. If so we wait until that node disconnects before ** informing the owner object that this node has been ejected. ** Otherwise, we complete the ejection process. */ if (m_EjectedNodeAlarmList2.IsEmpty()) { m_pConf->ProcessEjectUserIndication(m_eEjectReason); } } } // If we are the top provider, just clean the eject alarm list. else if (TOP_PROVIDER_AND_CONVENER_NODE == m_pConf->GetConfNodeType() && NULL != (lpAlarm = m_EjectedNodeAlarmList2.Remove(disconnected_user))) { delete lpAlarm; } /* ** Here we remove the entry from the list of child connections if ** it is included in this list. */ m_ChildUidConnHdlList2.Remove(disconnected_user); } /* * void ProcessApplicationInvokeIndication () * * Private Function Description: * This routine is responsible for processing an incoming Invoke * indication PDU. * * Formal Parameters: * invoke_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser::ProcessApplicationInvokeIndication( PApplicationInvokeIndication invoke_indication, UserID sender_id) { GCCError error_value = GCC_NO_ERROR; BOOL process_pdu = FALSE; CInvokeSpecifierListContainer *invoke_list; PSetOfDestinationNodes set_of_destination_nodes; if (invoke_indication->bit_mask & DESTINATION_NODES_PRESENT) { set_of_destination_nodes = invoke_indication->destination_nodes; while (set_of_destination_nodes != NULL) { if (set_of_destination_nodes->value == m_nidMyself) { process_pdu = TRUE; break; } else { set_of_destination_nodes = set_of_destination_nodes->next; } } } else { process_pdu = TRUE; } if (process_pdu) { TRACE_OUT(("MCSUser: ProcessApplicationInvokeIndication: Process PDU")); DBG_SAVE_FILE_LINE invoke_list = new CInvokeSpecifierListContainer( invoke_indication->application_protocol_entity_list, &error_value); if ((invoke_list != NULL) && (error_value == GCC_NO_ERROR)) { m_pConf->ProcessAppInvokeIndication(invoke_list, sender_id); invoke_list->Release(); } else if (invoke_list == NULL) { error_value = GCC_ALLOCATION_FAILURE; } else { invoke_list->Release(); } if (error_value == GCC_ALLOCATION_FAILURE) { ERROR_OUT(("MCSUser::ProcessApplicationInvokeIndication: Allocation Failure")); ResourceFailureHandler(); } } else { WARNING_OUT(("MCSUser:ProcessApplicationInvokeIndication: Don't Process PDU")); } } /* * GCCError ProcessTextMessageIndication () * * Private Function Description: * This routine is responsible for processing an incoming Text * message indication PDU. * * Formal Parameters: * text_message_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * GCC_NO_ERROR - No error occured. * GCC_ALLOCATION_FAILURE - A resource error occured. * * Side Effects * None. * * Caveats * None. */ #ifdef JASPER GCCError MCSUser::ProcessTextMessageIndication( PTextMessageIndication text_message_indication, UserID sender_id) { LPWSTR gcc_unicode_string; GCCError rc; if (NULL != (gcc_unicode_string = ::My_strdupW2( text_message_indication->message.length, text_message_indication->message.value))) { rc = g_pControlSap->TextMessageIndication( m_pConf->GetConfID(), gcc_unicode_string, sender_id); } else { rc = GCC_ALLOCATION_FAILURE; } return rc; } #endif // JASPER /* * void ProcessRegistryMonitorIndication () * * Private Function Description: * This routine is responsible for processing an incoming Registry * monitor indication PDU. * * Formal Parameters: * monitor_indication - (i) This is the PDU structure to process * sender_id - (i) Node ID of node that sent this PDU. * * Return Value * None. * * Side Effects * None. * * Caveats * None. */ void MCSUser:: ProcessRegistryMonitorIndicationPDU ( PRegistryMonitorEntryIndication monitor_indication, UserID sender_id ) { if (sender_id == m_nidTopProvider) { CRegistry *pAppReg = m_pConf->GetRegistry(); if (NULL != pAppReg) { GCCError rc; UserRegistryMonitorInfo urmi; ::ZeroMemory(&urmi, sizeof(urmi)); // urmi.registry_key = NULL; // urmi.registry_item = NULL; DBG_SAVE_FILE_LINE urmi.registry_key = new CRegKeyContainer(&monitor_indication->key, &rc); if ((urmi.registry_key != NULL) && (rc == GCC_NO_ERROR)) { DBG_SAVE_FILE_LINE urmi.registry_item = new CRegItem(&monitor_indication->item, &rc); if ((urmi.registry_item != NULL) && (rc == GCC_NO_ERROR)) { // Set up the owner related variables if (monitor_indication->owner.choice == OWNED_CHOSEN) { urmi.owner_node_id = monitor_indication->owner.u.owned.node_id; urmi.owner_entity_id = monitor_indication->owner.u.owned.entity_id; } else { // urmi.owner_node_id = 0; // urmi.owner_entity_id = 0; } // Set up the modification rights if (monitor_indication->bit_mask & RESPONSE_MODIFY_RIGHTS_PRESENT) { urmi.modification_rights = (GCCModificationRights)monitor_indication->entry_modify_rights; } else { urmi.modification_rights = GCC_NO_MODIFICATION_RIGHTS_SPECIFIED; } pAppReg->ProcessMonitorIndicationPDU( urmi.registry_key, urmi.registry_item, urmi.modification_rights, urmi.owner_node_id, urmi.owner_entity_id); } else { rc = GCC_ALLOCATION_FAILURE; } } else { rc = GCC_ALLOCATION_FAILURE; } if (NULL != urmi.registry_key) { urmi.registry_key->Release(); } if (NULL != urmi.registry_item) { urmi.registry_item->Release(); } // Handle any resource errors if (rc == GCC_ALLOCATION_FAILURE) { ResourceFailureHandler(); } } else { WARNING_OUT(("MCSUser:ProcessRegistryMonitorIndication: invalid app registry")); } } else { WARNING_OUT(("MCSUser:ProcessRegistryMonitorIndication:" "Monitor Indication received from NON Top Provider")); } } /* * UINT ProcessDetachUserIndication() * * Private Function Description: * This function is called when the user object gets detach user * indications from nodes in it's subtree or it's parent node. * Depending upon the reason of the indication it sends to the * conference object the appropriate owner callback. * If the reason contained in the indication is UserInitiated or * provider initiated a DETACH USER INDICATION is sent to the con- * ference. The MCS reason is converted to GCC reason. If MCS * reason in indication is neither user initiated nor provider initiated * then the above owner callback carries a GCC reason ERROR_TERMINATION * else it carries a GCC reason USER_INITIATED. * If the detach user indication reveals the user id of the sendar as * the parent user id of this node a CONFERENCE_TERMINATE_INDICATION * is sent to the conference object. * * Formal Parameters: * mcs_reason - (i) MCS reason for being detached. * sender_id - (i) User ID of user being detached. * * Return Value * MCS_NO_ERROR is always returned fro this routine. * * Side Effects * None. * * Caveats * None. */ UINT MCSUser::ProcessDetachUserIndication( Reason mcs_reason, UserID detached_user) { GCCReason gcc_reason; if (detached_user == m_nidParent) { WARNING_OUT(("MCSUser: Fatal Error: Parent User Detached")); m_pConf->ProcessTerminateIndication(GCC_REASON_PARENT_DISCONNECTED); } else { TRACE_OUT(("MCSUser: User Detached: uid=0x%04x", (UINT) detached_user)); /* ** First, we check to see if the detching node was ejected. ** If not, translate the mcs reason to a gcc reason. */ if (m_EjectedNodeList.Find(detached_user)) { gcc_reason = GCC_REASON_NODE_EJECTED; // Remove this entry from the ejected node list. m_EjectedNodeList.Remove(detached_user); } else if (m_EjectedNodeAlarmList2.Find(detached_user)) { // Here we wait for the disconnect before removing the entry. gcc_reason = GCC_REASON_NODE_EJECTED; } else if ((mcs_reason == REASON_USER_REQUESTED) || (mcs_reason == REASON_PROVIDER_INITIATED)) { gcc_reason = GCC_REASON_USER_INITIATED; } else { gcc_reason = GCC_REASON_ERROR_TERMINATION; } m_pConf->ProcessDetachUserIndication(detached_user, gcc_reason); } return (MCS_NO_ERROR); } void MCSUser:: ProcessTokenGrabConfirm ( TokenID tidConductor, Result result ) { if (tidConductor == CONDUCTOR_TOKEN_ID) { m_pConf->ProcessConductorGrabConfirm(::TranslateMCSResultToGCCResult(result)); } else { ERROR_OUT(("MCSUser:Assertion Failure: Non Conductor Grab Confirm")); } } void MCSUser:: ProcessTokenGiveIndication ( TokenID tidConductor, UserID uidRecipient ) { if (tidConductor == CONDUCTOR_TOKEN_ID) { m_pConf->ProcessConductorGiveIndication(uidRecipient); } else { ERROR_OUT(("MCSUser:Assertion Failure: Non Conductor Please Ind")); } } void MCSUser:: ProcessTokenGiveConfirm ( TokenID tidConductor, Result result ) { if (tidConductor == CONDUCTOR_TOKEN_ID) { m_pConf->ProcessConductorGiveConfirm(::TranslateMCSResultToGCCResult(result)); } else { ERROR_OUT(("MCSUser:Assertion Failure: Non Conductor Grab Confirm")); } } #ifdef JASPER void MCSUser:: ProcessTokenPleaseIndication ( TokenID tidConductor, UserID uidRequester ) { if (tidConductor == CONDUCTOR_TOKEN_ID) { if (m_pConf->IsConfConductible()) { // Inform the control SAP. g_pControlSap->ConductorPleaseIndication( m_pConf->GetConfID(), uidRequester); } } else { ERROR_OUT(("MCSUser:Assertion Failure: Non Conductor Please Ind")); } } #endif // JASPER #ifdef JASPER void MCSUser:: ProcessTokenReleaseConfirm ( TokenID tidConductor, Result result ) { if (tidConductor == CONDUCTOR_TOKEN_ID) { g_pControlSap->ConductorReleaseConfirm(::TranslateMCSResultToGCCResult(result), m_pConf->GetConfID()); } else { ERROR_OUT(("MCSUser:Assertion Failure: Non Conductor Release Cfrm")); } } #endif // JASPER void MCSUser:: ProcessTokenTestConfirm ( TokenID tidConductor, TokenStatus eStatus ) { if (tidConductor == CONDUCTOR_TOKEN_ID) { m_pConf->ProcessConductorTestConfirm((eStatus == TOKEN_NOT_IN_USE) ? GCC_RESULT_NOT_IN_CONDUCTED_MODE : GCC_RESULT_SUCCESSFUL); } else { ERROR_OUT(("MCSUser:Assertion Failure: Non Conductor Release Cfrm")); } } void MCSUser::ResourceFailureHandler(void) { ERROR_OUT(("MCSUser::ResourceFailureHandler: terminating the conference")); m_pConf->InitiateTermination(GCC_REASON_ERROR_LOW_RESOURCES, 0); }