3562 lines
99 KiB
C++
3562 lines
99 KiB
C++
/*
|
|
* connect.h
|
|
*
|
|
* Copyright (c) 1993 - 1995 by DataBeam Corporation, Lexington, KY
|
|
*
|
|
* Abstract:
|
|
* This is the interface file for the Connection class. Instances of
|
|
* this class are used to connect CommandTarget objects within the local
|
|
* provider to CommandTarget objects in a remote provider. This class
|
|
* inherits from CommandTarget, allowing it to communicate with other
|
|
* CommandTarget classes using their common MCS command language.
|
|
*
|
|
* This class can be thought of as providing a Remote Procedure Call (RPC)
|
|
* facility between CommandTarget objects. When an MCS command is sent
|
|
* to a Connection object, it encodes the command as a T.125 Protocol
|
|
* Data Unit (PDU) and sends it to a remote provider via the transport
|
|
* services provided by a TransportInterface object. At the remote side
|
|
* The PDU is received by a Connection object who decodes the PDU, and
|
|
* issues the equivalent MCS command to the CommandTarget object that it is
|
|
* attached to. The fact that the call crossed a transport connection
|
|
* in route to its destination is completely transparent to the object
|
|
* that initiated the command sequence.
|
|
*
|
|
* The primary responsibility of this class is to convert MCS commands
|
|
* to T.125 PDUs and back again (as described above). This class overrides
|
|
* all of the commands that are defined in class CommandTarget.
|
|
*
|
|
* A secondary responsibility of this class is to provide flow control
|
|
* to and from the transport layer. To do this is keeps a queue of PDUs
|
|
* that need to be transmitted (actually it keeps 4 queues, one for each
|
|
* data priority). During each MCS heartbeat, all Connection objects are
|
|
* given the opportunity to flush PDUs from the queues. If the transport
|
|
* layer returns an error, the PDU in question will be re-tried during
|
|
* the next heartbeat. For data coming from the transport layer, this
|
|
* class provides code to allocate memory. If an allocation fails, then
|
|
* an error will be returned to the transport layer, effectively telling
|
|
* it that it needs to retry that data indication during the next
|
|
* heartbeat.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*
|
|
* Author:
|
|
* James P. Galvin, Jr.
|
|
*/
|
|
#ifndef _CONNECTION_
|
|
#define _CONNECTION_
|
|
|
|
/*
|
|
* These are the owner callback functions that a Connection object can send to
|
|
* its creator (which is typically the MCS controller).
|
|
*
|
|
* When a class uses an instance of the Connection class (or any other class
|
|
* that can issue owner callbacks), it is accepting the responsibility of
|
|
* receiving and handling these callbacks.
|
|
*
|
|
* Each owner callback function, along with a description of how its parameters
|
|
* are packed, is described in the following section.
|
|
*/
|
|
#define DELETE_CONNECTION 0
|
|
#define CONNECT_PROVIDER_CONFIRM 1
|
|
|
|
typedef struct
|
|
{
|
|
PDomainParameters domain_parameters;
|
|
Result result;
|
|
PMemory memory;
|
|
} ConnectConfirmInfo;
|
|
typedef ConnectConfirmInfo * PConnectConfirmInfo;
|
|
|
|
/*
|
|
* Owner Callback: DELETE_CONNECTION
|
|
* Parameter1: PDisconnectProviderIndication
|
|
* disconnect_provider_indication
|
|
* Parameter2: Unused
|
|
*
|
|
* Usage:
|
|
* This owner callback will be issued if the Connection detects a situation
|
|
* is which it is no longer valid. This can happen for several reasons:
|
|
* transmission or reception of a ConnectResult with a failed result
|
|
* code; transmission or reception of a DisconnectProviderUltimatum; or
|
|
* a Disconnect-Indication from the transport layer.
|
|
*/
|
|
|
|
/*
|
|
* Owner Callback: CONNECT_PROVIDER_CONFIRM
|
|
* Parameter1: PConnectConfirmInfo connect_confirm_info
|
|
* Parameter2: ConnectionHandle connection_handle
|
|
*
|
|
* Usage:
|
|
* This callback is issued when the connection object completes the
|
|
* building of a new MCS connection that was locally requested. This is to
|
|
* inform the requester that the connection is ready for use.
|
|
*/
|
|
|
|
/*
|
|
* This enumeration dsefines the various states that a transport connection
|
|
* can be in at any given time.
|
|
*/
|
|
typedef enum
|
|
{
|
|
TRANSPORT_CONNECTION_UNASSIGNED,
|
|
TRANSPORT_CONNECTION_PENDING,
|
|
TRANSPORT_CONNECTION_READY
|
|
} TransportConnectionState;
|
|
typedef TransportConnectionState * PTransportConnectionState;
|
|
|
|
|
|
/*
|
|
* This is the class definition for class CommandTarget.
|
|
*/
|
|
class Connection : public CAttachment
|
|
{
|
|
public:
|
|
|
|
Connection (
|
|
PDomain attachment,
|
|
ConnectionHandle connection_handle,
|
|
GCCConfID *calling_domain,
|
|
GCCConfID *called_domain,
|
|
PChar called_address,
|
|
BOOL fSecure,
|
|
BOOL upward_connection,
|
|
PDomainParameters domain_parameters,
|
|
PUChar user_data,
|
|
ULong user_data_length,
|
|
PMCSError connection_error);
|
|
Connection (
|
|
PDomain attachment,
|
|
ConnectionHandle connection_handle,
|
|
TransportConnection transport_connection,
|
|
BOOL upward_connection,
|
|
PDomainParameters domain_parameters,
|
|
PDomainParameters min_domain_parameters,
|
|
PDomainParameters max_domain_parameters,
|
|
PUChar user_data,
|
|
ULong user_data_length,
|
|
PMCSError connection_error);
|
|
~Connection ();
|
|
|
|
void RegisterTransportConnection (
|
|
TransportConnection transport_connection,
|
|
Priority priority);
|
|
|
|
private:
|
|
|
|
Void ConnectInitial (
|
|
GCCConfID *calling_domain,
|
|
GCCConfID *called_domain,
|
|
BOOL upward_connection,
|
|
PDomainParameters domain_parameters,
|
|
PDomainParameters min_domain_parameters,
|
|
PDomainParameters max_domain_parameters,
|
|
PUChar user_data,
|
|
ULong user_data_length);
|
|
Void ConnectResponse (
|
|
Result result,
|
|
PDomainParameters domain_parameters,
|
|
ConnectID connect_id,
|
|
PUChar user_data,
|
|
ULong user_data_length);
|
|
Void ConnectAdditional (
|
|
ConnectID connect_id,
|
|
Priority priority);
|
|
Void ConnectResult (
|
|
Result result,
|
|
Priority priority);
|
|
ULong ProcessConnectResponse (
|
|
PConnectResponsePDU pdu_structure);
|
|
Void ProcessConnectResult (
|
|
PConnectResultPDU pdu_structure);
|
|
Void IssueConnectProviderConfirm (
|
|
Result result);
|
|
Void DestroyConnection (
|
|
Reason reason);
|
|
Void AssignRemainingTransportConnections ();
|
|
TransportError CreateTransportConnection (
|
|
LPCTSTR called_address,
|
|
BOOL fSecure,
|
|
Priority priority);
|
|
TransportError AcceptTransportConnection (
|
|
TransportConnection transport_connection,
|
|
Priority priority);
|
|
Void AdjustDomainParameters (
|
|
PDomainParameters min_domain_parameters,
|
|
PDomainParameters max_domain_parameters,
|
|
PDomainParameters domain_parameters);
|
|
BOOL MergeDomainParameters (
|
|
PDomainParameters min_domain_parameters1,
|
|
PDomainParameters max_domain_parameters1,
|
|
PDomainParameters min_domain_parameters2,
|
|
PDomainParameters max_domain_parameters2);
|
|
#ifdef DEBUG
|
|
Void PrintDomainParameters (
|
|
PDomainParameters domain_parameters);
|
|
#endif // DEBUG
|
|
|
|
public:
|
|
|
|
inline TransportConnection GetTransportConnection (UInt priority)
|
|
{
|
|
return (Transport_Connection[priority]);
|
|
}
|
|
|
|
virtual Void PlumbDomainIndication (
|
|
ULong height_limit);
|
|
Void ErectDomainRequest (
|
|
UINT_PTR height_in_domain,
|
|
ULong throughput_interval);
|
|
Void RejectUltimatum (
|
|
Diagnostic diagnostic,
|
|
PUChar octet_string_address,
|
|
ULong octet_string_length);
|
|
Void MergeChannelsRequest (
|
|
CChannelAttributesList *merge_channel_list,
|
|
CChannelIDList *purge_channel_list);
|
|
Void MergeChannelsConfirm (
|
|
CChannelAttributesList *merge_channel_list,
|
|
CChannelIDList *purge_channel_list);
|
|
virtual Void PurgeChannelsIndication (
|
|
CUidList *purge_user_list,
|
|
CChannelIDList *purge_channel_list);
|
|
Void MergeTokensRequest (
|
|
CTokenAttributesList *merge_token_list,
|
|
CTokenIDList *purge_token_list);
|
|
Void MergeTokensConfirm (
|
|
CTokenAttributesList *merge_token_list,
|
|
CTokenIDList *purge_token_list);
|
|
virtual Void PurgeTokensIndication (
|
|
PDomain originator,
|
|
CTokenIDList *purge_token_ids);
|
|
virtual Void DisconnectProviderUltimatum (
|
|
Reason reason);
|
|
Void AttachUserRequest ( void );
|
|
virtual Void AttachUserConfirm (
|
|
Result result,
|
|
UserID uidInitiator);
|
|
Void DetachUserRequest (
|
|
Reason reason,
|
|
CUidList *user_id_list);
|
|
virtual Void DetachUserIndication (
|
|
Reason reason,
|
|
CUidList *user_id_list);
|
|
Void ChannelJoinRequest (
|
|
UserID uidInitiator,
|
|
ChannelID channel_id);
|
|
virtual Void ChannelJoinConfirm (
|
|
Result result,
|
|
UserID uidInitiator,
|
|
ChannelID requested_id,
|
|
ChannelID channel_id);
|
|
Void ChannelLeaveRequest (
|
|
CChannelIDList *channel_id_list);
|
|
Void ChannelConveneRequest (
|
|
UserID uidInitiator);
|
|
virtual Void ChannelConveneConfirm (
|
|
Result result,
|
|
UserID uidInitiator,
|
|
ChannelID channel_id);
|
|
Void ChannelDisbandRequest (
|
|
UserID uidInitiator,
|
|
ChannelID channel_id);
|
|
virtual Void ChannelDisbandIndication (
|
|
ChannelID channel_id);
|
|
Void ChannelAdmitRequest (
|
|
UserID uidInitiator,
|
|
ChannelID channel_id,
|
|
CUidList *user_id_list);
|
|
virtual Void ChannelAdmitIndication (
|
|
UserID uidInitiator,
|
|
ChannelID channel_id,
|
|
CUidList *user_id_list);
|
|
Void ChannelExpelRequest (
|
|
UserID uidInitiator,
|
|
ChannelID channel_id,
|
|
CUidList *user_id_list);
|
|
virtual Void ChannelExpelIndication (
|
|
ChannelID channel_id,
|
|
CUidList *user_id_list);
|
|
Void SendDataRequest ( PDataPacket data_packet )
|
|
{
|
|
QueueForTransmission ((PSimplePacket) data_packet,
|
|
data_packet->GetPriority());
|
|
};
|
|
virtual Void SendDataIndication (
|
|
UINT,
|
|
PDataPacket data_packet)
|
|
{
|
|
QueueForTransmission ((PSimplePacket) data_packet,
|
|
data_packet->GetPriority());
|
|
};
|
|
Void TokenGrabRequest (
|
|
UserID uidInitiator,
|
|
TokenID token_id);
|
|
virtual Void TokenGrabConfirm (
|
|
Result result,
|
|
UserID uidInitiator,
|
|
TokenID token_id,
|
|
TokenStatus token_status);
|
|
Void TokenInhibitRequest (
|
|
UserID uidInitiator,
|
|
TokenID token_id);
|
|
virtual Void TokenInhibitConfirm (
|
|
Result result,
|
|
UserID uidInitiator,
|
|
TokenID token_id,
|
|
TokenStatus token_status);
|
|
Void TokenGiveRequest (
|
|
PTokenGiveRecord pTokenGiveRec);
|
|
virtual Void TokenGiveIndication (
|
|
PTokenGiveRecord pTokenGiveRec);
|
|
Void TokenGiveResponse (
|
|
Result result,
|
|
UserID receiver_id,
|
|
TokenID token_id);
|
|
virtual Void TokenGiveConfirm (
|
|
Result result,
|
|
UserID uidInitiator,
|
|
TokenID token_id,
|
|
TokenStatus token_status);
|
|
Void TokenReleaseRequest (
|
|
UserID uidInitiator,
|
|
TokenID token_id);
|
|
virtual Void TokenReleaseConfirm (
|
|
Result result,
|
|
UserID uidInitiator,
|
|
TokenID token_id,
|
|
TokenStatus token_status);
|
|
Void TokenPleaseRequest (
|
|
UserID uidInitiator,
|
|
TokenID token_id);
|
|
virtual Void TokenPleaseIndication (
|
|
UserID uidInitiator,
|
|
TokenID token_id);
|
|
Void TokenTestRequest (
|
|
UserID uidInitiator,
|
|
TokenID token_id);
|
|
virtual Void TokenTestConfirm (
|
|
UserID uidInitiator,
|
|
TokenID token_id,
|
|
TokenStatus token_status);
|
|
virtual Void MergeDomainIndication (
|
|
MergeStatus merge_status);
|
|
|
|
private:
|
|
|
|
Void SendPacket (
|
|
PVoid pdu_structure,
|
|
int pdu_type,
|
|
Priority priority);
|
|
Void QueueForTransmission (
|
|
PSimplePacket packet,
|
|
Priority priority,
|
|
BOOL bFlush = TRUE);
|
|
BOOL FlushAMessage (
|
|
PSimplePacket packet,
|
|
Priority priority);
|
|
Void MergeChannelsRC (
|
|
ASN1choice_t choice,
|
|
CChannelAttributesList *merge_channel_list,
|
|
CChannelIDList *purge_channel_list);
|
|
Void MergeTokensRC (
|
|
ASN1choice_t choice,
|
|
CTokenAttributesList *merge_token_list,
|
|
CTokenIDList *purge_token_list);
|
|
Void UserChannelRI (
|
|
ASN1choice_t choice,
|
|
UINT reason_userID,
|
|
ChannelID channel_id,
|
|
CUidList *user_id_list);
|
|
|
|
public:
|
|
|
|
BOOL FlushMessageQueue();
|
|
BOOL FlushPriority (
|
|
Priority priority);
|
|
BOOL IsDomainTrafficAllowed() { return Domain_Traffic_Allowed; };
|
|
|
|
public:
|
|
|
|
// the old owner callback
|
|
TransportError HandleDataIndication(PTransportData, TransportConnection);
|
|
void HandleBufferEmptyIndication(TransportConnection transport_connection);
|
|
void HandleConnectConfirm(TransportConnection transport_connection);
|
|
void HandleDisconnectIndication(TransportConnection transport_connection, ULONG *pnNotify);
|
|
|
|
LPSTR GetCalledAddress(void) { return m_pszCalledAddress; }
|
|
|
|
private:
|
|
|
|
inline ULong ProcessMergeChannelsRequest (
|
|
PMergeChannelsRequestPDU pdu_structure);
|
|
inline ULong ProcessMergeChannelsConfirm (
|
|
PMergeChannelsConfirmPDU pdu_structure);
|
|
inline Void ProcessPurgeChannelIndication (
|
|
PPurgeChannelIndicationPDU pdu_structure);
|
|
inline ULong ProcessMergeTokensRequest (
|
|
PMergeTokensRequestPDU pdu_structure);
|
|
inline ULong ProcessMergeTokensConfirm (
|
|
PMergeTokensConfirmPDU pdu_structure);
|
|
inline Void ProcessPurgeTokenIndication (
|
|
PPurgeTokenIndicationPDU pdu_structure);
|
|
inline Void ProcessDisconnectProviderUltimatum (
|
|
PDisconnectProviderUltimatumPDU
|
|
pdu_structure);
|
|
inline Void ProcessAttachUserRequest (
|
|
PAttachUserRequestPDU pdu_structure);
|
|
inline Void ProcessAttachUserConfirm (
|
|
PAttachUserConfirmPDU pdu_structure);
|
|
inline Void ProcessDetachUserRequest (
|
|
PDetachUserRequestPDU pdu_structure);
|
|
inline Void ProcessDetachUserIndication (
|
|
PDetachUserIndicationPDU pdu_structure);
|
|
inline Void ProcessChannelJoinRequest (
|
|
PChannelJoinRequestPDU pdu_structure);
|
|
inline Void ProcessChannelJoinConfirm (
|
|
PChannelJoinConfirmPDU pdu_structure);
|
|
inline Void ProcessChannelLeaveRequest (
|
|
PChannelLeaveRequestPDU pdu_structure);
|
|
inline Void ProcessChannelConveneRequest (
|
|
PChannelConveneRequestPDU pdu_structure);
|
|
inline Void ProcessChannelConveneConfirm (
|
|
PChannelConveneConfirmPDU pdu_structure);
|
|
inline Void ProcessChannelDisbandRequest (
|
|
PChannelDisbandRequestPDU pdu_structure);
|
|
inline Void ProcessChannelDisbandIndication (
|
|
PChannelDisbandIndicationPDU
|
|
pdu_structure);
|
|
inline Void ProcessChannelAdmitRequest (
|
|
PChannelAdmitRequestPDU pdu_structure);
|
|
inline Void ProcessChannelAdmitIndication (
|
|
PChannelAdmitIndicationPDU pdu_structure);
|
|
inline Void ProcessChannelExpelRequest (
|
|
PChannelExpelRequestPDU pdu_structure);
|
|
inline Void ProcessChannelExpelIndication (
|
|
PChannelExpelIndicationPDU pdu_structure);
|
|
inline Void ProcessSendDataRequest (
|
|
PSendDataRequestPDU pdu_structure,
|
|
PDataPacket packet);
|
|
inline Void ProcessSendDataIndication (
|
|
PSendDataIndicationPDU pdu_structure,
|
|
PDataPacket packet);
|
|
inline Void ProcessUniformSendDataRequest (
|
|
PUniformSendDataRequestPDU pdu_structure,
|
|
PDataPacket packet);
|
|
inline Void ProcessUniformSendDataIndication (
|
|
PUniformSendDataIndicationPDU
|
|
pdu_structure,
|
|
PDataPacket packet);
|
|
inline Void ProcessTokenGrabRequest (
|
|
PTokenGrabRequestPDU pdu_structure);
|
|
inline Void ProcessTokenGrabConfirm (
|
|
PTokenGrabConfirmPDU pdu_structure);
|
|
inline Void ProcessTokenInhibitRequest (
|
|
PTokenInhibitRequestPDU pdu_structure);
|
|
inline Void ProcessTokenInhibitConfirm (
|
|
PTokenInhibitConfirmPDU pdu_structure);
|
|
inline Void ProcessTokenReleaseRequest (
|
|
PTokenReleaseRequestPDU pdu_structure);
|
|
inline Void ProcessTokenReleaseConfirm (
|
|
PTokenReleaseConfirmPDU pdu_structure);
|
|
inline Void ProcessTokenTestRequest (
|
|
PTokenTestRequestPDU pdu_structure);
|
|
inline Void ProcessTokenTestConfirm (
|
|
PTokenTestConfirmPDU pdu_structure);
|
|
inline Void ProcessRejectUltimatum (
|
|
PRejectUltimatumPDU pdu_structure);
|
|
inline Void ProcessTokenGiveRequest (
|
|
PTokenGiveRequestPDU pdu_structure);
|
|
inline Void ProcessTokenGiveIndication (
|
|
PTokenGiveIndicationPDU pdu_structure);
|
|
inline Void ProcessTokenGiveResponse (
|
|
PTokenGiveResponsePDU pdu_structure);
|
|
inline Void ProcessTokenGiveConfirm (
|
|
PTokenGiveConfirmPDU pdu_structure);
|
|
inline Void ProcessTokenPleaseRequest (
|
|
PTokenPleaseRequestPDU pdu_structure);
|
|
inline Void ProcessTokenPleaseIndication (
|
|
PTokenPleaseIndicationPDU pdu_structure);
|
|
inline Void ProcessPlumbDomainIndication (
|
|
PPlumbDomainIndicationPDU pdu_structure);
|
|
inline Void ProcessErectDomainRequest (
|
|
PErectDomainRequestPDU pdu_structure);
|
|
inline ULong ValidateConnectionRequest ();
|
|
|
|
private:
|
|
|
|
LPSTR m_pszCalledAddress;
|
|
UINT Encoding_Rules;
|
|
PDomain m_pDomain;
|
|
PDomain m_pPendingDomain;
|
|
ConnectionHandle Connection_Handle;
|
|
DomainParameters Domain_Parameters;
|
|
PMemory Connect_Response_Memory;
|
|
|
|
TransportConnection Transport_Connection[MAXIMUM_PRIORITIES];
|
|
int Transport_Connection_PDU_Type[MAXIMUM_PRIORITIES];
|
|
TransportConnectionState
|
|
Transport_Connection_State[MAXIMUM_PRIORITIES];
|
|
UINT Transport_Connection_Count;
|
|
CSimplePktQueue m_OutPktQueue[MAXIMUM_PRIORITIES];
|
|
|
|
Reason Deletion_Reason;
|
|
|
|
BOOL Upward_Connection;
|
|
BOOL m_fSecure;
|
|
BOOL Merge_In_Progress;
|
|
BOOL Domain_Traffic_Allowed;
|
|
BOOL Connect_Provider_Confirm_Pending;
|
|
};
|
|
|
|
/*
|
|
* ULong ProcessMergeChannelsRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "MergeChannelsRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline ULong Connection::ProcessMergeChannelsRequest (
|
|
PMergeChannelsRequestPDU pdu_structure)
|
|
{
|
|
PChannelAttributes channel_attributes;
|
|
PSetOfChannelIDs channel_ids;
|
|
PSetOfUserIDs user_ids;
|
|
CUidList admitted_list;
|
|
CChannelAttributesList merge_channel_list;
|
|
CChannelIDList purge_channel_list;
|
|
PSetOfPDUChannelAttributes merge_channels;
|
|
BOOL first_set = TRUE;
|
|
|
|
/*
|
|
* Retrieve values from the decoded PDU structure and fill in the
|
|
* parameters lists to be passed into the domain.
|
|
*/
|
|
merge_channels = pdu_structure->merge_channels;
|
|
while (merge_channels != NULL)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
channel_attributes = new ChannelAttributes;
|
|
|
|
/*
|
|
* Check to make to sure the memory allocation has succeeded. If
|
|
* the memory allocation fails we just return an error code which
|
|
* results in the PDU being rejected so that it may be tried again
|
|
* at a later time. If subsequent allocations fail, we must first
|
|
* free the memory for the successful allocations and then return.
|
|
*/
|
|
if (channel_attributes == NULL)
|
|
{
|
|
if (first_set)
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
else
|
|
{
|
|
while (NULL != (channel_attributes = merge_channel_list.Get()))
|
|
{
|
|
delete channel_attributes;
|
|
}
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
}
|
|
}
|
|
|
|
switch (merge_channels->value.choice)
|
|
{
|
|
case CHANNEL_ATTRIBUTES_STATIC_CHOSEN:
|
|
channel_attributes->channel_type = STATIC_CHANNEL;
|
|
channel_attributes->u.static_channel_attributes.channel_id =
|
|
merge_channels->value.u.
|
|
channel_attributes_static.channel_id;
|
|
break;
|
|
|
|
case CHANNEL_ATTRIBUTES_USER_ID_CHOSEN:
|
|
channel_attributes->channel_type = USER_CHANNEL;
|
|
channel_attributes->u.user_channel_attributes.joined =
|
|
merge_channels->value.u.
|
|
channel_attributes_user_id.joined;
|
|
channel_attributes->u.user_channel_attributes.user_id =
|
|
(UShort)merge_channels->value.u.
|
|
channel_attributes_user_id.user_id;
|
|
break;
|
|
|
|
case CHANNEL_ATTRIBUTES_PRIVATE_CHOSEN:
|
|
channel_attributes->channel_type = PRIVATE_CHANNEL;
|
|
user_ids = merge_channels->value.u.
|
|
channel_attributes_private.admitted;
|
|
channel_attributes->u.private_channel_attributes.joined =
|
|
merge_channels->value.u.
|
|
channel_attributes_private.joined;
|
|
channel_attributes->u.private_channel_attributes.channel_id=
|
|
(UShort)merge_channels->value.u.
|
|
channel_attributes_private.channel_id;
|
|
channel_attributes->u.private_channel_attributes.
|
|
channel_manager = (UShort)merge_channels->
|
|
value.u.channel_attributes_private.manager;
|
|
|
|
/*
|
|
* Retrieve all of the user ID's from the PDU structure and
|
|
* put them into the list to be passed into the domain.
|
|
*/
|
|
while (user_ids != NULL)
|
|
{
|
|
admitted_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
channel_attributes->u.private_channel_attributes.
|
|
admitted_list = &admitted_list;
|
|
break;
|
|
|
|
case CHANNEL_ATTRIBUTES_ASSIGNED_CHOSEN:
|
|
channel_attributes->channel_type = ASSIGNED_CHANNEL;
|
|
channel_attributes->u.assigned_channel_attributes.
|
|
channel_id = (UShort)merge_channels->value.u.
|
|
channel_attributes_assigned.channel_id;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Connection::ProcessMergeChannelsRequest "
|
|
"Bad channel attributes choice."));
|
|
break;
|
|
}
|
|
/*
|
|
* Put the channel attributes structure into the list to be passed
|
|
* into the domain. Retrieve the "next" merge channels structure.
|
|
*/
|
|
merge_channel_list.Append(channel_attributes);
|
|
merge_channels = merge_channels->next;
|
|
}
|
|
|
|
/*
|
|
* Retrieve all of the purge channel ID's from the PDU structure and
|
|
* put them into the list to be passed into the domain.
|
|
*/
|
|
channel_ids = pdu_structure->purge_channel_ids;
|
|
while (channel_ids != NULL)
|
|
{
|
|
purge_channel_list.Append(channel_ids->value);
|
|
channel_ids = channel_ids->next;
|
|
}
|
|
|
|
m_pDomain->MergeChannelsRequest(this, &merge_channel_list, &purge_channel_list);
|
|
|
|
/*
|
|
* Free any memory which was allocated for the channel attributes
|
|
* structures by setting up an iterator for the list of channel
|
|
* attributes and freeing the memory associated with each pointer.
|
|
*/
|
|
while (NULL != (channel_attributes = merge_channel_list.Get()))
|
|
{
|
|
delete channel_attributes;
|
|
}
|
|
return (TRANSPORT_NO_ERROR);
|
|
}
|
|
|
|
/*
|
|
* ULong ProcessMergeChannelsConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "MergeChannelsConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline ULong Connection::ProcessMergeChannelsConfirm (
|
|
PMergeChannelsConfirmPDU pdu_structure)
|
|
{
|
|
PChannelAttributes channel_attributes;
|
|
PSetOfChannelIDs channel_ids;
|
|
PSetOfUserIDs user_ids;
|
|
CUidList admitted_list;
|
|
CChannelAttributesList merge_channel_list;
|
|
CChannelIDList purge_channel_list;
|
|
PSetOfPDUChannelAttributes merge_channels;
|
|
BOOL first_set = TRUE;
|
|
|
|
/*
|
|
* Retrieve values from the decoded PDU structure and fill in the
|
|
* parameters lists to be passed into the domain.
|
|
*/
|
|
merge_channels = pdu_structure->merge_channels;
|
|
while (merge_channels != NULL)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
channel_attributes = new ChannelAttributes;
|
|
|
|
/*
|
|
* Check to make to sure the memory allocation has succeeded. If
|
|
* the memory allocation fails we just return an error code which
|
|
* results in the PDU being rejected so that it may be tried again
|
|
* at a later time. If subsequent allocations fail, we must first
|
|
* free the memory for the successful allocations and then return.
|
|
*/
|
|
if (channel_attributes == NULL)
|
|
{
|
|
if (first_set)
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
else
|
|
{
|
|
while (NULL != (channel_attributes = merge_channel_list.Get()))
|
|
{
|
|
delete channel_attributes;
|
|
}
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
}
|
|
}
|
|
|
|
switch (merge_channels->value.choice)
|
|
{
|
|
case CHANNEL_ATTRIBUTES_STATIC_CHOSEN:
|
|
channel_attributes->channel_type = STATIC_CHANNEL;
|
|
channel_attributes->u.static_channel_attributes.channel_id =
|
|
merge_channels->value.u.
|
|
channel_attributes_static.channel_id;
|
|
break;
|
|
|
|
case CHANNEL_ATTRIBUTES_USER_ID_CHOSEN:
|
|
channel_attributes->channel_type = USER_CHANNEL;
|
|
channel_attributes->u.user_channel_attributes.joined =
|
|
merge_channels->value.u.
|
|
channel_attributes_user_id.joined;
|
|
channel_attributes->u.user_channel_attributes.user_id =
|
|
(UShort)merge_channels->value.u.
|
|
channel_attributes_user_id.user_id;
|
|
break;
|
|
|
|
case CHANNEL_ATTRIBUTES_PRIVATE_CHOSEN:
|
|
channel_attributes->channel_type = PRIVATE_CHANNEL;
|
|
user_ids = merge_channels->value.u.
|
|
channel_attributes_private.admitted;
|
|
|
|
channel_attributes->u.private_channel_attributes.joined =
|
|
merge_channels->value.u.
|
|
channel_attributes_private.joined;
|
|
channel_attributes->u.private_channel_attributes.channel_id=
|
|
(UShort)merge_channels->value.u.
|
|
channel_attributes_private.channel_id;
|
|
channel_attributes->u.private_channel_attributes.
|
|
channel_manager = (UShort)merge_channels->
|
|
value.u.channel_attributes_private.manager;
|
|
|
|
/*
|
|
* Retrieve all of the user ID's from the PDU structure and
|
|
* put them into the list to be passed into the domain.
|
|
*/
|
|
while (user_ids != NULL)
|
|
{
|
|
admitted_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
channel_attributes->u.private_channel_attributes.
|
|
admitted_list = &admitted_list;
|
|
break;
|
|
|
|
case CHANNEL_ATTRIBUTES_ASSIGNED_CHOSEN:
|
|
channel_attributes->channel_type = ASSIGNED_CHANNEL;
|
|
channel_attributes->u.assigned_channel_attributes.
|
|
channel_id = (UShort)merge_channels->value.u.
|
|
channel_attributes_assigned.channel_id;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Connection::ProcessMergeChannelsConfirm "
|
|
"Bad channel attributes choice."));
|
|
break;
|
|
}
|
|
/*
|
|
* Put the channel attributes structure into the list to be passed
|
|
* into the domain. Retrieve the "next" merge channels structure.
|
|
*/
|
|
merge_channel_list.Append(channel_attributes);
|
|
merge_channels = merge_channels->next;
|
|
}
|
|
|
|
/*
|
|
* Retrieve all of the purge channel ID's from the PDU structure and
|
|
* put them into the list to be passed into the domain.
|
|
*/
|
|
channel_ids = pdu_structure->purge_channel_ids;
|
|
while (channel_ids != NULL)
|
|
{
|
|
purge_channel_list.Append(channel_ids->value);
|
|
channel_ids = channel_ids->next;
|
|
}
|
|
|
|
m_pDomain->MergeChannelsConfirm(this, &merge_channel_list, &purge_channel_list);
|
|
|
|
/*
|
|
* Free any memory which was allocated for the channel attributes
|
|
* structures by setting up an iterator for the list of channel
|
|
* attributes and freeing the memory associated with each pointer.
|
|
*/
|
|
while (NULL != (channel_attributes = merge_channel_list.Get()))
|
|
{
|
|
delete channel_attributes;
|
|
}
|
|
return (TRANSPORT_NO_ERROR);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessPurgeChannelIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "PurgeChannelsIndication" PDU's being
|
|
* received through the transport interface. The pertinent data is read
|
|
* from the incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessPurgeChannelIndication (
|
|
PPurgeChannelIndicationPDU pdu_structure)
|
|
{
|
|
CUidList purge_user_list;
|
|
CChannelIDList purge_channel_list;
|
|
PSetOfChannelIDs channel_ids;
|
|
PSetOfUserIDs user_ids;
|
|
|
|
/*
|
|
* Retrieve all of the purge user ID's from the PDU structure and put
|
|
* them into the list to be passed into the domain.
|
|
*/
|
|
user_ids = pdu_structure->detach_user_ids;
|
|
|
|
while (user_ids != NULL)
|
|
{
|
|
purge_user_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
|
|
/*
|
|
* Retrieve all of the purge channel ID's from the PDU structure and
|
|
* put them into the list to be passed into the domain.
|
|
*/
|
|
channel_ids = pdu_structure->purge_channel_ids;
|
|
while (channel_ids != NULL)
|
|
{
|
|
purge_channel_list.Append(channel_ids->value);
|
|
channel_ids = channel_ids->next;
|
|
}
|
|
|
|
m_pDomain->PurgeChannelsIndication(this, &purge_user_list, &purge_channel_list);
|
|
}
|
|
|
|
/*
|
|
* ULong ProcessMergeTokensRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "MergeTokenRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline ULong Connection::ProcessMergeTokensRequest (
|
|
PMergeTokensRequestPDU pdu_structure)
|
|
{
|
|
PTokenAttributes token_attributes;
|
|
PSetOfTokenIDs token_ids;
|
|
PSetOfUserIDs user_ids;
|
|
CUidList inhibited_list;
|
|
CTokenAttributesList merge_token_list;
|
|
CTokenIDList purge_token_list;
|
|
PSetOfPDUTokenAttributes merge_tokens;
|
|
BOOL first_set = TRUE;
|
|
|
|
/*
|
|
* Retrieve values from the decoded PDU structure and fill in the
|
|
* parameters lists to be passed into the domain.
|
|
*/
|
|
merge_tokens = pdu_structure->merge_tokens;
|
|
|
|
while (merge_tokens != NULL)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
token_attributes = new TokenAttributes;
|
|
|
|
/*
|
|
* Check to make to sure the memory allocation has succeeded. If
|
|
* the memory allocation fails we just return an error code which
|
|
* results in the PDU being rejected so that it may be tried again
|
|
* at a later time. If subsequent allocations fail, we must first
|
|
* free the memory for the successful allocations and then return.
|
|
*/
|
|
if (token_attributes == NULL)
|
|
{
|
|
if (first_set)
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
else
|
|
{
|
|
while (NULL != (token_attributes = merge_token_list.Get()))
|
|
{
|
|
delete token_attributes;
|
|
}
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
}
|
|
}
|
|
|
|
switch (merge_tokens->value.choice)
|
|
{
|
|
case GRABBED_CHOSEN:
|
|
token_attributes->token_state = TOKEN_GRABBED;
|
|
token_attributes->u.grabbed_token_attributes.token_id =
|
|
(UShort)merge_tokens->value.u.
|
|
grabbed.token_id;
|
|
token_attributes->u.grabbed_token_attributes.grabber =
|
|
(UShort)merge_tokens->
|
|
value.u.grabbed.grabber;
|
|
break;
|
|
|
|
case INHIBITED_CHOSEN:
|
|
token_attributes->token_state = TOKEN_INHIBITED;
|
|
user_ids = merge_tokens->value.u.
|
|
inhibited.inhibitors;
|
|
|
|
token_attributes->u.inhibited_token_attributes.token_id =
|
|
(UShort)merge_tokens->
|
|
value.u.inhibited.token_id;
|
|
/*
|
|
* Retrieve all of the user ID's from the PDU structure and
|
|
* put them into the list to be passed into the domain.
|
|
*/
|
|
while (user_ids != NULL)
|
|
{
|
|
inhibited_list.Append(user_ids->value);
|
|
user_ids= user_ids->next;
|
|
}
|
|
token_attributes->u.inhibited_token_attributes.
|
|
inhibitors = &inhibited_list;
|
|
break;
|
|
|
|
case GIVING_CHOSEN:
|
|
token_attributes->token_state = TOKEN_GIVING;
|
|
token_attributes->u.giving_token_attributes.token_id =
|
|
(UShort)merge_tokens->
|
|
value.u.giving.token_id;
|
|
token_attributes->u.giving_token_attributes.grabber =
|
|
(UShort)merge_tokens->
|
|
value.u.giving.grabber;
|
|
token_attributes->u.giving_token_attributes.recipient =
|
|
(UShort)merge_tokens->value.u.giving.
|
|
recipient;
|
|
break;
|
|
|
|
case GIVEN_CHOSEN:
|
|
token_attributes->token_state = TOKEN_GIVEN;
|
|
token_attributes->u.given_token_attributes.token_id =
|
|
(UShort)merge_tokens->
|
|
value.u.given.token_id;
|
|
token_attributes->u.given_token_attributes.recipient =
|
|
(UShort)merge_tokens->
|
|
value.u.given.recipient;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Connection::ProcessMergeTokensRequest "
|
|
"Bad token attributes choice."));
|
|
break;
|
|
}
|
|
/*
|
|
* Put the token attributes structure into the list to be passed
|
|
* into the domain. We are only doing one channel attributes
|
|
* structures at a time for now.
|
|
*/
|
|
merge_token_list.Append(token_attributes);
|
|
merge_tokens = merge_tokens->next;
|
|
}
|
|
|
|
/*
|
|
* Retrieve all of the purge token ID's from the PDU structure and put
|
|
* them into the list to be passed into the domain.
|
|
*/
|
|
token_ids = pdu_structure->purge_token_ids;
|
|
while (token_ids != NULL)
|
|
{
|
|
purge_token_list.Append(token_ids->value);
|
|
token_ids = token_ids->next;
|
|
}
|
|
|
|
m_pDomain->MergeTokensRequest(this, &merge_token_list, &purge_token_list);
|
|
|
|
/*
|
|
* Free any memory which was allocated for the token attributes
|
|
* structures by setting up an iterator for the list of token
|
|
* attributes and freeing the memory associated with each pointer.
|
|
*/
|
|
while (NULL != (token_attributes = merge_token_list.Get()))
|
|
{
|
|
delete token_attributes;
|
|
}
|
|
return (TRANSPORT_NO_ERROR);
|
|
}
|
|
|
|
/*
|
|
* ULong ProcessMergeTokensConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "MergeTokenConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline ULong Connection::ProcessMergeTokensConfirm (
|
|
PMergeTokensConfirmPDU pdu_structure)
|
|
{
|
|
PTokenAttributes token_attributes;
|
|
PSetOfTokenIDs token_ids;
|
|
PSetOfUserIDs user_ids;
|
|
CUidList inhibited_list;
|
|
CTokenAttributesList merge_token_list;
|
|
CTokenIDList purge_token_list;
|
|
PSetOfPDUTokenAttributes merge_tokens;
|
|
BOOL first_set = TRUE;
|
|
|
|
/*
|
|
* Retrieve values from the decoded PDU structure and fill in the
|
|
* parameters lists to be passed into the domain.
|
|
*/
|
|
merge_tokens = pdu_structure->merge_tokens;
|
|
|
|
while (merge_tokens != NULL)
|
|
{
|
|
DBG_SAVE_FILE_LINE
|
|
token_attributes = new TokenAttributes;
|
|
|
|
/*
|
|
* Check to make to sure the memory allocation has succeeded. If
|
|
* the memory allocation fails we just return an error code which
|
|
* results in the PDU being rejected so that it may be tried again
|
|
* at a later time. If subsequent allocations fail, we must first
|
|
* free the memory for the successful allocations and then return.
|
|
*/
|
|
if (token_attributes == NULL)
|
|
{
|
|
if (first_set)
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
else
|
|
{
|
|
while (NULL != (token_attributes = merge_token_list.Get()))
|
|
{
|
|
delete token_attributes;
|
|
}
|
|
return (TRANSPORT_READ_QUEUE_FULL);
|
|
}
|
|
}
|
|
|
|
switch (merge_tokens->value.choice)
|
|
{
|
|
case GRABBED_CHOSEN:
|
|
token_attributes->token_state = TOKEN_GRABBED;
|
|
token_attributes->u.grabbed_token_attributes.token_id =
|
|
(UShort)merge_tokens->value.u.
|
|
grabbed.token_id;
|
|
token_attributes->u.grabbed_token_attributes.grabber =
|
|
(UShort)merge_tokens->
|
|
value.u.grabbed.grabber;
|
|
break;
|
|
|
|
case INHIBITED_CHOSEN:
|
|
token_attributes->token_state = TOKEN_INHIBITED;
|
|
user_ids = merge_tokens->value.u.
|
|
inhibited.inhibitors;
|
|
|
|
token_attributes->u.inhibited_token_attributes.token_id =
|
|
(UShort)merge_tokens->
|
|
value.u.inhibited.token_id;
|
|
/*
|
|
* Retrieve all of the user ID's from the PDU structure and
|
|
* put them into the list to be passed into the domain.
|
|
*/
|
|
while (user_ids != NULL)
|
|
{
|
|
inhibited_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
token_attributes->u.inhibited_token_attributes.
|
|
inhibitors = &inhibited_list;
|
|
break;
|
|
|
|
case GIVING_CHOSEN:
|
|
token_attributes->token_state = TOKEN_GIVING;
|
|
token_attributes->u.giving_token_attributes.token_id =
|
|
(UShort)merge_tokens->
|
|
value.u.giving.token_id;
|
|
token_attributes->u.giving_token_attributes.grabber =
|
|
(UShort)merge_tokens->
|
|
value.u.giving.grabber;
|
|
token_attributes->u.giving_token_attributes.recipient =
|
|
(UShort)merge_tokens->value.u.giving.
|
|
recipient;
|
|
break;
|
|
|
|
case GIVEN_CHOSEN:
|
|
token_attributes->token_state = TOKEN_GIVEN;
|
|
token_attributes->u.given_token_attributes.token_id =
|
|
(UShort)merge_tokens->
|
|
value.u.given.token_id;
|
|
token_attributes->u.given_token_attributes.recipient =
|
|
(UShort)merge_tokens->
|
|
value.u.given.recipient;
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Connection::ProcessMergeTokensConfirm "
|
|
"Bad token attributes choice."));
|
|
break;
|
|
}
|
|
/*
|
|
* Put the token attributes structure into the list to be passed
|
|
* into the domain. We are only doing one channel attributes
|
|
* structures at a time for now.
|
|
*/
|
|
merge_token_list.Append(token_attributes);
|
|
merge_tokens = merge_tokens->next;
|
|
}
|
|
|
|
/*
|
|
* Retrieve all of the purge token ID's from the PDU structure and put
|
|
* them into the list to be passed into the domain.
|
|
*/
|
|
token_ids = pdu_structure->purge_token_ids;
|
|
while (token_ids != NULL)
|
|
{
|
|
purge_token_list.Append(token_ids->value);
|
|
token_ids = token_ids->next;
|
|
}
|
|
|
|
m_pDomain->MergeTokensConfirm(this, &merge_token_list, &purge_token_list);
|
|
|
|
/*
|
|
* Free any memory which was allocated for the token attributes
|
|
* structures by setting up an iterator for the list of token
|
|
* attributes and freeing the memory associated with each pointer.
|
|
*/
|
|
while (NULL != (token_attributes = merge_token_list.Get()))
|
|
{
|
|
delete token_attributes;
|
|
}
|
|
return (TRANSPORT_NO_ERROR);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessPurgeTokenIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "PurgeTokenIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessPurgeTokenIndication (
|
|
PPurgeTokenIndicationPDU pdu_structure)
|
|
{
|
|
PSetOfTokenIDs token_ids;
|
|
CTokenIDList purge_token_list;
|
|
|
|
/*
|
|
* Retrieve all of the purge token ID's from the PDU structure and put
|
|
* them into the list to be passed into the domain.
|
|
*/
|
|
token_ids = pdu_structure->purge_token_ids;
|
|
while (token_ids != NULL)
|
|
{
|
|
purge_token_list.Append(token_ids->value);
|
|
token_ids = token_ids->next;
|
|
}
|
|
|
|
m_pDomain->PurgeTokensIndication(this, &purge_token_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessDisconnectProviderUltimatum()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "DisconnectProviderUltimatum" PDU's being
|
|
* received through the transport interface. The pertinent data is read
|
|
* from the incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessDisconnectProviderUltimatum (
|
|
PDisconnectProviderUltimatumPDU pdu_structure)
|
|
{
|
|
TRACE_OUT(("Connection::ProcessDisconnectProviderUltimatum: PDU received"));
|
|
|
|
m_pDomain->DisconnectProviderUltimatum(this, (Reason)pdu_structure->reason);
|
|
m_pDomain = NULL;
|
|
}
|
|
|
|
/*
|
|
* Void ProcessAttachUserRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "AttachUserRequest" PDU's being received
|
|
* through the transport interface by forwarding the request on to the
|
|
* domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessAttachUserRequest (PAttachUserRequestPDU)
|
|
{
|
|
m_pDomain->AttachUserRequest(this);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessAttachUserConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "AttachUserConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessAttachUserConfirm (
|
|
PAttachUserConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->AttachUserConfirm(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->initiator);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessDetachUserRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "DetachUserRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessDetachUserRequest (
|
|
PDetachUserRequestPDU pdu_structure)
|
|
{
|
|
PSetOfUserIDs user_ids;
|
|
CUidList user_id_list;
|
|
|
|
/*
|
|
* Retrieve the user ID's from the PDU structure and put them into the
|
|
* list to be passed into the domain.
|
|
*/
|
|
user_ids = pdu_structure->user_ids;
|
|
while (user_ids != NULL)
|
|
{
|
|
user_id_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
|
|
m_pDomain->DetachUserRequest(this, (Reason) pdu_structure->reason, &user_id_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessDetachUserIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "DetachUserIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessDetachUserIndication (
|
|
PDetachUserIndicationPDU pdu_structure)
|
|
{
|
|
PSetOfUserIDs user_ids;
|
|
CUidList user_id_list;
|
|
|
|
/*
|
|
* Retrieve the user ID's from the PDU structure and put them into the
|
|
* list to be passed into the domain.
|
|
*/
|
|
user_ids = pdu_structure->user_ids;
|
|
while (user_ids != NULL)
|
|
{
|
|
user_id_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
|
|
m_pDomain->DetachUserIndication(this, (Reason) pdu_structure->reason,
|
|
&user_id_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelJoinRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelJoinRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelJoinRequest (
|
|
PChannelJoinRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->ChannelJoinRequest(this, (UserID) pdu_structure->initiator,
|
|
(ChannelID) pdu_structure->channel_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelJoinConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelJoinConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelJoinConfirm (
|
|
PChannelJoinConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->ChannelJoinConfirm(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->initiator,
|
|
(ChannelID) pdu_structure->requested,
|
|
(ChannelID) pdu_structure->join_channel_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelLeaveRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelLeaveRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelLeaveRequest (
|
|
PChannelLeaveRequestPDU pdu_structure)
|
|
{
|
|
PSetOfChannelIDs channel_ids;
|
|
CChannelIDList channel_id_list;
|
|
|
|
/*
|
|
* Retrieve the channel ID's from the PDU structure and put them into
|
|
* the list to be passed into the domain.
|
|
*/
|
|
channel_ids = pdu_structure->channel_ids;
|
|
while (channel_ids != NULL)
|
|
{
|
|
channel_id_list.Append(channel_ids->value);
|
|
channel_ids = channel_ids->next;
|
|
}
|
|
|
|
m_pDomain->ChannelLeaveRequest(this, &channel_id_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelConveneRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelConveneRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelConveneRequest (
|
|
PChannelConveneRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->ChannelConveneRequest(this, (UserID) pdu_structure->initiator);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelConveneConfirm ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelConveneConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelConveneConfirm (
|
|
PChannelConveneConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->ChannelConveneConfirm(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->initiator,
|
|
(ChannelID) pdu_structure->convene_channel_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelDisbandRequest ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelDisbandRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelDisbandRequest (
|
|
PChannelDisbandRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->ChannelDisbandRequest(this, (UserID) pdu_structure->initiator,
|
|
(ChannelID) pdu_structure->channel_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelDisbandIndication ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelDisbandIndication" PDU's being
|
|
* received through the transport interface. The pertinent data is read
|
|
* from the incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelDisbandIndication (
|
|
PChannelDisbandIndicationPDU pdu_structure)
|
|
{
|
|
m_pDomain->ChannelDisbandIndication(this, (ChannelID) pdu_structure->channel_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelAdmitRequest ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelAdmitRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelAdmitRequest (
|
|
PChannelAdmitRequestPDU pdu_structure)
|
|
{
|
|
PSetOfUserIDs user_ids;
|
|
CUidList user_id_list;
|
|
|
|
/*
|
|
* Retrieve the user ID's from the PDU structure and put them into the
|
|
* list to be passed into the domain.
|
|
*/
|
|
user_ids = pdu_structure->user_ids;
|
|
while (user_ids != NULL)
|
|
{
|
|
user_id_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
|
|
m_pDomain->ChannelAdmitRequest(this, (UserID) pdu_structure->initiator,
|
|
(ChannelID) pdu_structure->channel_id,
|
|
&user_id_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelAdmitIndication ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelAdmitIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelAdmitIndication (
|
|
PChannelAdmitIndicationPDU pdu_structure)
|
|
{
|
|
PSetOfUserIDs user_ids;
|
|
CUidList user_id_list;
|
|
|
|
/*
|
|
* Retrieve the user ID's from the PDU structure and put them into the
|
|
* list to be passed into the domain.
|
|
*/
|
|
user_ids = pdu_structure->user_ids;
|
|
while (user_ids != NULL)
|
|
{
|
|
user_id_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
|
|
m_pDomain->ChannelAdmitIndication(this, (UserID) pdu_structure->initiator,
|
|
(ChannelID) pdu_structure->channel_id,
|
|
&user_id_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelExpelRequest ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelExpelRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelExpelRequest (
|
|
PChannelExpelRequestPDU pdu_structure)
|
|
{
|
|
PSetOfUserIDs user_ids;
|
|
CUidList user_id_list;
|
|
|
|
/*
|
|
* Retrieve the user ID's from the PDU structure and put them into the
|
|
* list to be passed into the domain.
|
|
*/
|
|
user_ids = pdu_structure->user_ids;
|
|
while (user_ids != NULL)
|
|
{
|
|
user_id_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
|
|
m_pDomain->ChannelExpelRequest(this, (UserID) pdu_structure->initiator,
|
|
(ChannelID) pdu_structure->channel_id,
|
|
&user_id_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessChannelExpelIndication ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ChannelExpelIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessChannelExpelIndication (
|
|
PChannelExpelIndicationPDU pdu_structure)
|
|
{
|
|
PSetOfUserIDs user_ids;
|
|
CUidList user_id_list;
|
|
|
|
/*
|
|
* Retrieve the user ID's from the PDU structure and put them into the
|
|
* list to be passed into the domain.
|
|
*/
|
|
user_ids = pdu_structure->user_ids;
|
|
while (user_ids != NULL)
|
|
{
|
|
user_id_list.Append(user_ids->value);
|
|
user_ids = user_ids->next;
|
|
}
|
|
|
|
m_pDomain->ChannelExpelIndication(this, (ChannelID) pdu_structure->channel_id,
|
|
&user_id_list);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessSendDataRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "SendDataRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessSendDataRequest (
|
|
PSendDataRequestPDU pdu_structure,
|
|
PDataPacket packet)
|
|
{
|
|
m_pDomain->SendDataRequest(this, MCS_SEND_DATA_INDICATION, packet);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessSendDataIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "SendDataIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessSendDataIndication (
|
|
PSendDataIndicationPDU pdu_structure,
|
|
PDataPacket data_packet)
|
|
{
|
|
m_pDomain->SendDataIndication(this, MCS_SEND_DATA_INDICATION, data_packet);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessUniformSendDataRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "UniformSendDataRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessUniformSendDataRequest (
|
|
PUniformSendDataRequestPDU pdu_structure,
|
|
PDataPacket packet)
|
|
{
|
|
m_pDomain->SendDataRequest(this, MCS_UNIFORM_SEND_DATA_INDICATION, packet);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessUniformSendDataIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "UniformSendDataIndication" PDU's being
|
|
* received through the transport interface. The pertinent data is read
|
|
* from the incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessUniformSendDataIndication (
|
|
PUniformSendDataIndicationPDU pdu_structure,
|
|
PDataPacket data_packet)
|
|
{
|
|
m_pDomain->SendDataIndication(this, MCS_UNIFORM_SEND_DATA_INDICATION, data_packet);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenGrabRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenGrabRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenGrabRequest (
|
|
PTokenGrabRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenGrabRequest(this, (UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenGrabConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenGrabConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenGrabConfirm (
|
|
PTokenGrabConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenGrabConfirm(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id,
|
|
(TokenStatus)pdu_structure->token_status);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenInhibitRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenInhibitRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenInhibitRequest (
|
|
PTokenInhibitRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenInhibitRequest(this, (UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenInhibitConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenInhibitConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenInhibitConfirm (
|
|
PTokenInhibitConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenInhibitConfirm(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id,
|
|
(TokenStatus)pdu_structure->token_status);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenReleaseRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenReleaseRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenReleaseRequest (
|
|
PTokenReleaseRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenReleaseRequest(this, (UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenReleaseConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenReleaseConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenReleaseConfirm (
|
|
PTokenReleaseConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenReleaseConfirm(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id,
|
|
(TokenStatus)pdu_structure->token_status);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenTestRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenTestRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenTestRequest (
|
|
PTokenTestRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenTestRequest(this, (UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenTestConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenTestConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenTestConfirm (
|
|
PTokenTestConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenTestConfirm(this, (UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id,
|
|
(TokenStatus)pdu_structure->token_status);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessRejectUltimatum()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "RejectUltimatum" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessRejectUltimatum (
|
|
PRejectUltimatumPDU pdu_structure)
|
|
{
|
|
m_pDomain->RejectUltimatum(this,
|
|
pdu_structure->diagnostic,
|
|
pdu_structure->initial_octets.value,
|
|
(ULong) pdu_structure->initial_octets.length);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenGiveRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenGiveRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenGiveRequest (
|
|
PTokenGiveRequestPDU pdu_structure)
|
|
{
|
|
TokenGiveRecord TokenGiveRec;
|
|
|
|
// Fill in the TokenGive record
|
|
TokenGiveRec.uidInitiator = pdu_structure->initiator;
|
|
TokenGiveRec.token_id = pdu_structure->token_id;
|
|
TokenGiveRec.receiver_id = pdu_structure->recipient;
|
|
m_pDomain->TokenGiveRequest(this, &TokenGiveRec);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenGiveIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenGiveIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenGiveIndication (
|
|
PTokenGiveIndicationPDU pdu_structure)
|
|
{
|
|
TokenGiveRecord TokenGiveRec;
|
|
|
|
// Fill in the TokenGive record
|
|
TokenGiveRec.uidInitiator = pdu_structure->initiator;
|
|
TokenGiveRec.token_id = pdu_structure->token_id;
|
|
TokenGiveRec.receiver_id = pdu_structure->recipient;
|
|
m_pDomain->TokenGiveIndication(this, &TokenGiveRec);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenGiveResponse()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenGiveResponse" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenGiveResponse (
|
|
PTokenGiveResponsePDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenGiveResponse(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->recipient,
|
|
(TokenID) pdu_structure->token_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenGiveConfirm()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenGiveConfirm" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenGiveConfirm (
|
|
PTokenGiveConfirmPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenGiveConfirm(this, (Result) pdu_structure->result,
|
|
(UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id,
|
|
(TokenStatus)pdu_structure->token_status);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenPleaseRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenPleaseRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenPleaseRequest (
|
|
PTokenPleaseRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenPleaseRequest(this, (UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessTokenPleaseIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "TokenPleaseIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessTokenPleaseIndication (
|
|
PTokenPleaseIndicationPDU pdu_structure)
|
|
{
|
|
m_pDomain->TokenPleaseIndication(this, (UserID) pdu_structure->initiator,
|
|
(TokenID) pdu_structure->token_id);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessPlumbDomainIndication()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "PlumbDomainIndication" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessPlumbDomainIndication (
|
|
PPlumbDomainIndicationPDU pdu_structure)
|
|
{
|
|
m_pDomain->PlumbDomainIndication(this, pdu_structure->height_limit);
|
|
}
|
|
|
|
/*
|
|
* Void ProcessErectDomainRequest()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This routine processes the "ErectDomainRequest" PDU's being received
|
|
* through the transport interface. The pertinent data is read from the
|
|
* incoming packet and passed on to the domain.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline Void Connection::ProcessErectDomainRequest (
|
|
PErectDomainRequestPDU pdu_structure)
|
|
{
|
|
m_pDomain->ErectDomainRequest(this, pdu_structure->sub_height,
|
|
pdu_structure->sub_interval);
|
|
}
|
|
|
|
/*
|
|
* ULong ValidateConnectionRequest ()
|
|
*
|
|
* Private
|
|
*
|
|
* Functional Description:
|
|
* This function is used to determine if it is valid to process an incoming
|
|
* request at the current time. It checks several different conditions
|
|
* to determine this, as follows:
|
|
*
|
|
* - If there is a merge in progress, then the request is not valid.
|
|
* - If this MCS connection is not yet bound to a domain, then the request
|
|
* is not valid.
|
|
* - If there are not enough objects of the Memory, Packet, or UserMessage
|
|
* class to handle a reasonable request, then the request is not valid.
|
|
*
|
|
* Note that the check on number of objects is not an absolute guarantee
|
|
* that there will be enough to handle a given request, because a request
|
|
* can result in MANY PDUs and user messages being generated. For example,
|
|
* a single channel admit request can result in lots of channel admit
|
|
* indications being sent. However, checking against a minimum number
|
|
* of objects can reduce the possibility of failure to be astronomically
|
|
* low. And remember, even if MCS runs out of something while processing
|
|
* such a request, it WILL handle it properly (by cleanly destroying the
|
|
* user attachment or MCS connection upon which the failure occurred). So
|
|
* there is no chance of MCS crashing as a result of this.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
inline ULong Connection::ValidateConnectionRequest ()
|
|
{
|
|
ULong return_value;
|
|
|
|
/*
|
|
* Check to see if there is a domain merger in progress.
|
|
*/
|
|
if (Merge_In_Progress == FALSE)
|
|
{
|
|
/*
|
|
* Make sure that this MCS connection is bound to a domain.
|
|
*/
|
|
if (m_pDomain != NULL)
|
|
{
|
|
/*
|
|
* Everything is okay, so the request is to be permitted.
|
|
*/
|
|
return_value = TRANSPORT_NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* We are not yet attached to a domain.
|
|
*/
|
|
TRACE_OUT (("Connection::ValidateConnectionRequest: "
|
|
"not attached to a domain"));
|
|
return_value = TRANSPORT_READ_QUEUE_FULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* There is a domain merge in progress.
|
|
*/
|
|
WARNING_OUT (("Connection::ValidateConnectionRequest: "
|
|
"domain merger in progress"));
|
|
return_value = TRANSPORT_READ_QUEUE_FULL;
|
|
}
|
|
|
|
return (return_value);
|
|
}
|
|
|
|
/*
|
|
* Connection (
|
|
* PCommandTarget attachment,
|
|
* ConnectionHandle connection_handle,
|
|
* PUChar calling_domain,
|
|
* UINT calling_domain_length,
|
|
* PUChar called_domain,
|
|
* UINT called_domain_length,
|
|
* PChar calling_address,
|
|
* PChar called_address,
|
|
* BOOL upward_connection,
|
|
* PDomainParameters domain_parameters,
|
|
* PUChar user_data,
|
|
* ULong user_data_length,
|
|
* PMCSError connection_error)
|
|
*
|
|
* Functional Description:
|
|
* This is a constructor for the Connection class. This constructor
|
|
* is used for creating outbound connections. It initializes private
|
|
* instance variables and calls the transport interface to set up a
|
|
* transport connection and register this connection object (through a
|
|
* callback structure) with the transport object.
|
|
*
|
|
* Formal Parameters:
|
|
* packet_coder
|
|
* This is the coder which is used by the connection object to encode
|
|
* PDU's into, and decode PDU's from, ASN.1 compliant byte streams.
|
|
* attachment
|
|
* The Domain to which this connection object is attached.
|
|
* connection_handle
|
|
* The handle which uniquely identifies this connection object.
|
|
* owner_object
|
|
* This is a pointer to the owner of this connection object (typically
|
|
* the MCS Controller) which allows this connection to communicate with
|
|
* the owner through callbacks.
|
|
* owner_message_base
|
|
* This is the base value to which offsets are added to identify which
|
|
* callback routine in the owner object this connection is calling.
|
|
* calling_domain
|
|
* This is a pointer to an ASCII string which contains the name of the
|
|
* domain to which this connection object is attached.
|
|
* calling_domain_length
|
|
* The length of the ASCII string which is the name of domain to which
|
|
* this connection object is attached.
|
|
* called_domain
|
|
* This is a pointer to an ASCII string which contains the name of the
|
|
* remote domain with which this connection will communicate.
|
|
* called_domain_length
|
|
* The length of the ASCII string which is the name of the remote
|
|
* domain.
|
|
* calling_address
|
|
* The transport address of the caller.
|
|
* called_address
|
|
* The transport address of the party being called.
|
|
* upward_connection
|
|
* This is a boolean flag which indicates whether this is an upward
|
|
* connection or a downward connection.
|
|
* domain_parameters
|
|
* This is the set of parameters which describes the local domain.
|
|
* user_data
|
|
* This is a pointer to a buffer containing data which is sent to the
|
|
* remote provider through the "ConnectInitial" PDU.
|
|
* user_data_length
|
|
* The length of the user data described above.
|
|
* connection_error
|
|
* A return parameter which indicates any errors which may have
|
|
* occurred in construction of the connection object.
|
|
*
|
|
* Return Value:
|
|
* MCS_NO_ERROR The connection was created successfully.
|
|
* MCS_TRANSPORT_FAILED An error occurred in creating the transport
|
|
* connection.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* Connection (
|
|
* PCommandTarget attachment,
|
|
* ConnectionHandle connection_handle,
|
|
* TransportConnection transport_connection,
|
|
* BOOL upward_connection,
|
|
* PDomainParameters domain_parameters,
|
|
* PDomainParameters min_domain_parameters,
|
|
* PDomainParameters max_domain_parameters,
|
|
* PUChar user_data,
|
|
* ULong user_data_length,
|
|
* PMCSError connection_error)
|
|
*
|
|
* Functional Description:
|
|
* This is a constructor for the Connection class. This constructor is
|
|
* used for creating inbound connections and is called when a transport
|
|
* connection already exists. It initializes private instance variables
|
|
* and calls the transport interface to register this connection object
|
|
* (through a callback structure) with the transport object.
|
|
*
|
|
* Formal Parameters:
|
|
* attachment
|
|
* The Domain to which this connection object is attached.
|
|
* connection_handle
|
|
* The handle which uniquely identifies this connection object.
|
|
* owner_object
|
|
* This is a pointer to the owner of this connection object (typically
|
|
* the MCS Controller) which allows this connection to communicate with
|
|
* the owner through callbacks.
|
|
* owner_message_base
|
|
* This is the base value to which offsets are added to identify which
|
|
* callback routine in the owner object this connection is calling.
|
|
* transport_connection
|
|
* This is the object used by this connection to communicate with the
|
|
* transport layer.
|
|
* upward_connection
|
|
* This is a boolean flag which indicates whether this is an upward
|
|
* connection or a downward connection.
|
|
* domain_parameters
|
|
* This is the set of parameters which describes the local domain.
|
|
* min_domain_parameters
|
|
* This is the set of parameters which describes the minimum
|
|
* permissable values for local domain parameters.
|
|
* max_domain_parameters
|
|
* This is the set of parameters which describes the maximum
|
|
* permissable values for local domain parameters.
|
|
* user_data
|
|
* This is a pointer to a buffer containing data which is sent to the
|
|
* remote provider through the "ConnectInitial" PDU.
|
|
* user_data_length
|
|
* The length of the user data described above.
|
|
* connection_error
|
|
* A return parameter which indicates any errors which may have
|
|
* occurred in construction of the connection object.
|
|
*
|
|
* Return Value:
|
|
* MCS_NO_ERROR
|
|
* The connection was created successfully.
|
|
* MCS_TRANSPORT_FAILED
|
|
* An error occurred in accepting the transport connection.
|
|
* MCS_BAD_DOMAIN_PARAMETERS
|
|
* There was no acceptable overlap between the local and remote
|
|
* domain parameters.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* ~Connection ()
|
|
*
|
|
* Functional Description:
|
|
* This is the destructor for the Connection class. If no connection
|
|
* deletion is pending, it terminates the current connection by issuing
|
|
* a DisconnectProviderUltimatum to the domain, transmitting a
|
|
* "DISCONNECT_PROVIDER_ULTIMATUM" PDU, and issuing a DisconnectRequest
|
|
* to the transport interface. The destructor also clears the transmission
|
|
* queue and frees any allocated memory.
|
|
*
|
|
* Formal Parameters:
|
|
* None.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* void RegisterTransportConnection ()
|
|
*
|
|
* Functional Description:
|
|
* This routine is called in order to register the transport connection
|
|
* with the connection object.
|
|
*
|
|
* Formal Parameters:
|
|
* None.
|
|
*
|
|
* Return Value:
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void PlumbDomainIndication (
|
|
* PCommandTarget originator,
|
|
* ULong height_limit)
|
|
*
|
|
* Functional Description:
|
|
* This routine is called by the domain in order to send a
|
|
* "PlumbDomainIndication" PDU through the transport interface.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* height_limit
|
|
* This is the number of connections between this user and the
|
|
* top provider.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* Void ErectDomainRequest (
|
|
* PCommandTarget originator,
|
|
* ULong height_in_domain,
|
|
* ULong throughput_interval)
|
|
*
|
|
* Functional Description:
|
|
* This routine is called by the domain in order to send a
|
|
* "ErectDomainRequest" PDU through the transport interface.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* height_in_domain
|
|
* This is the number of connections between this user and the
|
|
* top provider.
|
|
* throughput_interval
|
|
* The minimum number of octets per second required.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* Void RejectUltimatum (
|
|
* PCommandTarget originator,
|
|
* Diagnostic diagnostic,
|
|
* PUChar octet_string_address,
|
|
* ULong octet_string_length)
|
|
*
|
|
* Functional Description:
|
|
* This routine is called by the domain in order to send a
|
|
* "RejectUltimatum" PDU through the transport interface.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* diagnostic
|
|
* An enumeration indicating the reason for this reject.
|
|
* octet_string_address
|
|
* A pointer to the PDU data which resulted in the reject.
|
|
* octet_string_length
|
|
* The length of the PDU data which resulted in the reject.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void MergeChannelsRequest (
|
|
* PCommandTarget originator,
|
|
* CChannelAttributesList *merge_channel_list,
|
|
* CChannelIDList *purge_channel_list)
|
|
*
|
|
* Functional Description:
|
|
* This routine is called by the domain in order to send a
|
|
* "MergeChannelsRequest" PDU through the transport interface.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* merge_channel_list
|
|
* This is a list of attributes describing the channels which are to
|
|
* be merged.
|
|
* purge_channel_list
|
|
* This is a list of ID's for the channels that are to be purged.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void MergeChannelsConfirm (
|
|
* PCommandTarget originator,
|
|
* CChannelAttributesList *merge_channel_list,
|
|
* CChannelIDList *purge_channel_list)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* MergeChannelConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* merge_channel_list
|
|
* This is a list of attributes describing the channels which are to
|
|
* be merged.
|
|
* purge_channel_list
|
|
* This is a list of ID's for the channels that are to be purged.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* Void PurgeChannelsIndication (
|
|
* PCommandTarget originator,
|
|
* CUidList *purge_user_list,
|
|
* CChannelIDList *purge_channel_list)
|
|
*
|
|
* Functional Description:
|
|
* This routine is called by the domain in order to send a
|
|
* "PurgeChannelsIndication" PDU through the transport interface.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* purge_user_list
|
|
* This is a list of IDs of the users being purged.
|
|
* purge_channel_list
|
|
* This is a list of IDs of the channels being purged.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void MergeTokensRequest (
|
|
* PCommandTarget originator,
|
|
* CTokenAttributesList *merge_token_list,
|
|
* CTokenIDList *purge_token_list)
|
|
*
|
|
* Functional Description:
|
|
* This routine is called by the domain in order to send a
|
|
* "MergeTokensRequest" PDU through the transport interface.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* merge_token_list
|
|
* This is a list of attributes describing the tokens which are to
|
|
* be merged.
|
|
* purge_token_list
|
|
* This is a list of ID's for the tokens that are to be purged.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void MergeTokensConfirm (
|
|
* PCommandTarget originator,
|
|
* CTokenAttributesList *merge_token_list,
|
|
* CTokenIDList *purge_token_list)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* MergeTokensConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* merge_token_list
|
|
* This is a list of attributes describing the tokens which are to
|
|
* be merged.
|
|
* purge_token_list
|
|
* This is a list of ID's for the tokens that are to be purged.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void PurgeTokensIndication (
|
|
* PCommandTarget originator,
|
|
* CTokenIDList *purge_token_ids)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* PurgeTokenIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* purge_token_ids
|
|
* This is a list of ID's for the tokens that are to be purged.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void DisconnectProviderUltimatum (
|
|
* PCommandTarget originator,
|
|
* Reason reason)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* DisconnectProviderUltimatum command to the remote attachment. Note
|
|
* that this command automatically causes this Connection object to
|
|
* destroy itself.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* reason
|
|
* The reason for the diconnect.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void AttachUserRequest (
|
|
* PCommandTarget originator)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* AttachUserRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void AttachUserConfirm (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID uidInitiator)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* AttachUserConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* The result of the attach request.
|
|
* uidInitiator
|
|
* If the result was successful, this will contain the unique user
|
|
* ID to be associated with this user.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void DetachUserRequest (
|
|
* PCommandTarget originator,
|
|
* Reason reason,
|
|
* UserID user_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* DetachUserRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* reason
|
|
* This is the reason for the detachment.
|
|
* user_id
|
|
* The ID of the user who wishes to detach.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void DetachUserIndication (
|
|
* PCommandTarget originator,
|
|
* Reason reason,
|
|
* UserID user_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* DetachUserIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* reason
|
|
* The reason for the detachment.
|
|
* user_id
|
|
* The ID of the user who has detached.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelJoinRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* ChannelID channel_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelJoinRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user who initiated the request.
|
|
* channel_id
|
|
* The ID of the channel to be joined.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelJoinConfirm (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID uidInitiator,
|
|
* ChannelID requested_id,
|
|
* ChannelID channel_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelJoinConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* The result of the join request.
|
|
* uidInitiator
|
|
* The ID of the user who initiated the request.
|
|
* requested_id
|
|
* This ID of the channel that the user attempted to join (which may
|
|
* be 0).
|
|
* channel_id
|
|
* The ID of the channel being joined.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelLeaveRequest (
|
|
* PCommandTarget originator,
|
|
* CChannelIDList *channel_id_list)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelLeaveRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* channel_id_list
|
|
* The list of IDs of the channels to be left.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelConveneRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelConveneRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* This is the ID of the user who is trying to convene a private
|
|
* channel.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelConveneConfirm (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID uidInitiator,
|
|
* ChannelID channel_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelConveneConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* This is the result of the previously requested convene operation.
|
|
* uidInitiator
|
|
* This is the ID of the user who tried to convene a new channel.
|
|
* channel_id
|
|
* If the request was successful, this is the ID of the newly created
|
|
* private channel.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelDisbandRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* ChannelID channel_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelDisbandRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* This is the ID of the user who is trying to disband a private
|
|
* channel.
|
|
* channel_id
|
|
* This is the ID of the channel being disbanded.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelDisbandIndication (
|
|
* PCommandTarget originator,
|
|
* ChannelID channel_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelDisbandIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* channel_id
|
|
* This is the ID of the channel being disbanded.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelAdmitRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* ChannelID channel_id,
|
|
* CUidList *user_id_list)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelAdmitRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* This is the ID of the user who is trying to admit some users to
|
|
* a private channel.
|
|
* channel_id
|
|
* This is the ID of the channel to be affected.
|
|
* user_id_list
|
|
* This is a container holding the IDs of the users to be admitted.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelAdmitIndication (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* ChannelID channel_id,
|
|
* CUidList *user_id_list)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelAdmitIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* This is the ID of the user who is trying to admit some users to
|
|
* a private channel.
|
|
* channel_id
|
|
* This is the ID of the channel to be affected.
|
|
* user_id_list
|
|
* This is a container holding the IDs of the users to be admitted.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelExpelRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* ChannelID channel_id,
|
|
* CUidList *user_id_list)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelExpelRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* This is the ID of the user who is trying to expel some users from
|
|
* a private channel.
|
|
* channel_id
|
|
* This is the ID of the channel to be affected.
|
|
* user_id_list
|
|
* This is a container holding the IDs of the users to be expelled.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void ChannelExpelIndication (
|
|
* PCommandTarget originator,
|
|
* ChannelID channel_id,
|
|
* CUidList *user_id_list)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* ChannelExpelIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* channel_id
|
|
* This is the ID of the channel to be affected.
|
|
* user_id_list
|
|
* This is a container holding the IDs of the users to be expelled.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* Void SendDataRequest (
|
|
* PCommandTarget originator,
|
|
* UINT type,
|
|
PDataPacket data_packet)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* SendDataRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator (i)
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* type (i)
|
|
* Normal or uniform send data request
|
|
* pDataPacket (i)
|
|
* This is a pointer to a DataPacket object containing the channel
|
|
* ID, the User ID of the data sender, segmentation flags, priority of
|
|
* the data packet and a pointer to the packet to be sent.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* Void SendDataIndication (
|
|
* PCommandTarget originator,
|
|
* UINT type,
|
|
* PDataPacket data_packet)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* SendDataIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* type (i)
|
|
* normal or uniform data indication
|
|
* data_packet (i)
|
|
* This is a pointer to a DataPacket object containing the channel
|
|
* ID, the User ID of the data sender, segmentation flags, priority of
|
|
* the data packet and a pointer to the packet to be sent.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenGrabRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenGrabRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user attempting to grab the token.
|
|
* token_id
|
|
* The ID of the token being grabbed.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenGrabConfirm (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id,
|
|
* TokenStatus token_status)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenGrabConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* The result of the grab operation.
|
|
* uidInitiator
|
|
* The ID of the user attempting to grab the token.
|
|
* token_id
|
|
* The ID of the token being grabbed.
|
|
* token_status
|
|
* The status of the token after processing the request.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenInhibitRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenInhibitRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user attempting to inhibit the token.
|
|
* token_id
|
|
* The ID of the token being inhibited.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenInhibitConfirm (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id,
|
|
* TokenStatus token_status)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenInhibitConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* The result of the inhibit operation.
|
|
* uidInitiator
|
|
* The ID of the user attempting to inhibit the token.
|
|
* token_id
|
|
* The ID of the token being inhibited.
|
|
* token_status
|
|
* The status of the token after processing the request.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenGiveRequest (
|
|
* PCommandTarget originator,
|
|
* PTokenGiveRecord pTokenGiveRec)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenGiveRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* pTokenGiveRec (i)
|
|
* This is the address of a structure containing the following information:
|
|
* The ID of the user attempting to give away the token.
|
|
* The ID of the token being given.
|
|
* The ID of the user that the token is being given to.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenGiveIndication (
|
|
* PCommandTarget originator,
|
|
* PTokenGiveRecord pTokenGiveRec)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenGiveIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* pTokenGiveRec (i)
|
|
* This is the address of a structure containing the following information:
|
|
* The ID of the user attempting to give away the token.
|
|
* The ID of the token being given.
|
|
* The ID of the user that the token is being given to.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenGiveResponse (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID receiver_id,
|
|
* TokenID token_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenGiveResponse command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* The result of the give operation.
|
|
* receiver_id
|
|
* The ID of the user being given the token.
|
|
* token_id
|
|
* The ID of the token being given.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenGiveConfirm (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id,
|
|
* TokenStatus token_status)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenGiveConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* The result of the give operation.
|
|
* uidInitiator
|
|
* The ID of the user being given the token.
|
|
* token_id
|
|
* The ID of the token being given.
|
|
* token_status
|
|
* The status of the token after processing the request.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenReleaseRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenReleaseRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user attempting to release the token.
|
|
* token_id
|
|
* The ID of the token being released.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenReleaseConfirm (
|
|
* PCommandTarget originator,
|
|
* Result result,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id,
|
|
* TokenStatus token_status)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenReleaseConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* result
|
|
* The result of the release operation.
|
|
* uidInitiator
|
|
* The ID of the user attempting to release the token.
|
|
* token_id
|
|
* The ID of the token being released.
|
|
* token_status
|
|
* The status of the token after processing the request.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenPleaseRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenPleaseRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user requesting the token.
|
|
* token_id
|
|
* The ID of the token being requested.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenPleaseIndication (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenPleaseIndication command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user requesting the token.
|
|
* token_id
|
|
* The ID of the token being requested.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenTestRequest (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenTestRequest command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user testing the token.
|
|
* token_id
|
|
* The ID of the token being tested.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void TokenTestConfirm (
|
|
* PCommandTarget originator,
|
|
* UserID uidInitiator,
|
|
* TokenID token_id,
|
|
* TokenStatus token_status)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when the local attachment wishes to send a
|
|
* TokenTestConfirm command to the remote attachment.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* uidInitiator
|
|
* The ID of the user testing the token.
|
|
* token_id
|
|
* The ID of the token being tested.
|
|
* token_status
|
|
* The status of the token after processing the request.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void MergeDomainIndication (
|
|
* PCommandTarget originator,
|
|
* MergeStatus merge_status)
|
|
*
|
|
* Functional Description:
|
|
* This command is received when a domain enters or leaves the domain merge
|
|
* state. When in a domain merge state, NO commands are to be sent to
|
|
* the Domain object.
|
|
*
|
|
* Formal Parameters:
|
|
* originator
|
|
* This is the address of the CommandTarget that issued this command.
|
|
* merge_status
|
|
* This is the current status of the domain merge. It indicates
|
|
* whether the merge is active, or just completed.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* All command traffic to the Domain object must halt when the domain is
|
|
* in the merge state.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
/*
|
|
* Void FlushMessageQueue()
|
|
*
|
|
* Functional Description:
|
|
* This function is called by the controller during the MCS heartbeat to
|
|
* allow it to flush its output buffers. If there is any data waiting
|
|
* to be transmitted (at any priority), the Connection object will attempt
|
|
* to send it at this time.
|
|
*
|
|
* Formal Parameters:
|
|
* None.
|
|
*
|
|
* Return Value:
|
|
* None.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
/*
|
|
* ULong OwnerCallback (
|
|
* unsigned int message,
|
|
* PVoid parameter1,
|
|
TransportConnection transport_connection)
|
|
*
|
|
* Functional Description:
|
|
* This function is used to receive owner callbacks from the Transport
|
|
* Interface object. Connection objects sends data and requests to
|
|
* the Transport Interface object through its public interface, but it
|
|
* receives data and indications through this owner callback. For a more
|
|
* complete description of the callbacks, and how the parameter for each
|
|
* one are packed, see the interface file for the class TransportInterface
|
|
* (since it is this class that originates the callbacks).
|
|
*
|
|
* Formal Parameters:
|
|
* message
|
|
* This is the message to be processed. These are defined in the
|
|
* interface file of the class issuing the callbacks.
|
|
* parameter1
|
|
* The meaning of this parameter varies according to the message
|
|
* being processed.
|
|
* transport_connection
|
|
* The transport connection on which the callback applies.
|
|
*
|
|
* Return Value:
|
|
* The meaning of the return value varies according to the message being
|
|
* processed.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*/
|
|
|
|
#endif
|